{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 分类训练"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 机器学习的HelloWorld ，一个新的分类算法，都会看看在MNIST的上的执行结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2051, 60000, 28, 28)\n",
      "47040000\n"
     ]
    }
   ],
   "source": [
    "# 导入数据\n",
    "import struct\n",
    "# 从指定路径读取数据\n",
    "with open('./MNIST_data/train-images-idx3-ubyte', 'rb') as f:\n",
    "    # 内容\n",
    "    buffer = f.read(4*4) # 4个int\n",
    "    # 解析出4个int类型\n",
    "    head = struct.unpack('>iiii',buffer)\n",
    "    print(head)\n",
    "    # 读图片 像素6w*28*28\n",
    "    length = head[1] * head[2]  * head[3]\n",
    "    print(length)\n",
    "    # 像素包\n",
    "    buffer = f.read(length)\n",
    "    # 读取的字节数\n",
    "    data = struct.unpack('>{}B'.format(length),buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将数据转换维度,把所有的图片按照数据集格式进行分组\n",
    "1. head[1]：图片数量\n",
    "2. head[2]：图片行信息占有数量\n",
    "3. head[3]：图片列信息占有数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "imgs = np.reshape(data, (head[1], head[2], head[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs.shape # 结果：6w个图片 28行 28列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAOEUlEQVR4nO3dcYwV5bnH8d8jLUalENSIG9Ha22Bym0YXQUJiU6lNG4sm0JhWiHFp2mRJLAk1jam2q5DUGxujNGoicaukWLlCFS3Y1EsNS/TemDSuSBVLW6mhdMuGFTWyxEQqPPePHZoVd95Zzpk5c+D5fpLNOWeenTOPx/0xc847c15zdwE49Z1WdwMAWoOwA0EQdiAIwg4EQdiBID7Vyo2ZGR/9AxVzdxtreVN7djO7xsz+Yma7zey2Zp4LQLWs0XF2M5sg6a+SviZpQNLLkha7+58S67BnBypWxZ59jqTd7v6Wux+WtF7SgiaeD0CFmgn7BZL+MerxQLbsY8ys28z6zay/iW0BaFIzH9CNdajwicN0d++V1CtxGA/UqZk9+4CkC0c9ni5pX3PtAKhKM2F/WdIMM/ucmU2UtEjS5nLaAlC2hg/j3f0jM1smaYukCZLWuPsbpXUGoFQND701tDHeswOVq+SkGgAnD8IOBEHYgSAIOxAEYQeCIOxAEIQdCIKwA0EQdiAIwg4EQdiBIAg7EARhB4Ig7EAQhB0IgrADQRB2IAjCDgRB2IEgCDsQBGEHgmjplM049cyaNStZX7ZsWW6tq6srue5jjz2WrD/44IPJ+vbt25P1aNizA0EQdiAIwg4EQdiBIAg7EARhB4Ig7EAQzOKKpM7OzmS9r68vWZ88eXKZ7XzM+++/n6yfc845lW27neXN4trUSTVmtkfSsKQjkj5y99nNPB+A6pRxBt1X3P1ACc8DoEK8ZweCaDbsLun3ZvaKmXWP9Qtm1m1m/WbW3+S2ADSh2cP4K919n5mdJ+l5M/uzu784+hfcvVdSr8QHdECdmtqzu/u+7HZI0jOS5pTRFIDyNRx2MzvLzD5z7L6kr0vaWVZjAMrVzGH8NEnPmNmx5/lvd/+fUrpCy8yZkz4Y27hxY7I+ZcqUZD11Hsfw8HBy3cOHDyfrRePoc+fOza0VXetetO2TUcNhd/e3JF1WYi8AKsTQGxAEYQeCIOxAEIQdCIKwA0Fwiesp4Mwzz8ytXX755cl1H3/88WR9+vTpyXo29Jor9fdVNPx1zz33JOvr169P1lO99fT0JNe9++67k/V2lneJK3t2IAjCDgRB2IEgCDsQBGEHgiDsQBCEHQiCKZtPAQ8//HBubfHixS3s5MQUnQMwadKkZP2FF15I1ufNm5dbu/TSS5PrnorYswNBEHYgCMIOBEHYgSAIOxAEYQeCIOxAEIyznwRmzZqVrF977bW5taLrzYsUjWU/++yzyfq9996bW9u3b19y3VdffTVZf++995L1q6++OrfW7OtyMmLPDgRB2IEgCDsQBGEHgiDsQBCEHQiCsANB8L3xbaCzszNZ7+vrS9YnT57c8Lafe+65ZL3oevirrroqWU9dN/7II48k13377beT9SJHjhzJrX3wwQfJdYv+u4q+875ODX9vvJmtMbMhM9s5atnZZva8mb2Z3U4ts1kA5RvPYfwvJV1z3LLbJG119xmStmaPAbSxwrC7+4uS3j1u8QJJa7P7ayUtLLkvACVr9Nz4ae4+KEnuPmhm5+X9opl1S+pucDsASlL5hTDu3iupV+IDOqBOjQ697TezDknKbofKawlAFRoN+2ZJS7L7SyRtKqcdAFUpHGc3syckzZN0rqT9klZI+o2kX0u6SNJeSd9y9+M/xBvruUIexl9yySXJ+ooVK5L1RYsWJesHDhzIrQ0ODibXveuuu5L1p556KllvZ6lx9qK/+w0bNiTrN954Y0M9tULeOHvhe3Z3zzur4qtNdQSgpThdFgiCsANBEHYgCMIOBEHYgSD4KukSnH766cl66uuUJWn+/PnJ+vDwcLLe1dWVW+vv70+ue8YZZyTrUV100UV1t1A69uxAEIQdCIKwA0EQdiAIwg4EQdiBIAg7EATj7CWYOXNmsl40jl5kwYIFyXrRtMqAxJ4dCIOwA0EQdiAIwg4EQdiBIAg7EARhB4JgnL0Eq1atStbNxvxm338rGidnHL0xp52Wvy87evRoCztpD+zZgSAIOxAEYQeCIOxAEIQdCIKwA0EQdiAIxtnH6brrrsutdXZ2Jtctmh548+bNDfWEtNRYetH/kx07dpTdTu0K9+xmtsbMhsxs56hlK83sn2a2I/tp7tsZAFRuPIfxv5R0zRjLf+7undnP78ptC0DZCsPu7i9KercFvQCoUDMf0C0zs9eyw/ypeb9kZt1m1m9m6UnHAFSq0bCvlvR5SZ2SBiXdl/eL7t7r7rPdfXaD2wJQgobC7u773f2Iux+V9AtJc8ptC0DZGgq7mXWMevhNSTvzfhdAeygcZzezJyTNk3SumQ1IWiFpnpl1SnJJeyQtrbDHtpCax3zixInJdYeGhpL1DRs2NNTTqa5o3vuVK1c2/Nx9fX3J+u23397wc7erwrC7++IxFj9aQS8AKsTpskAQhB0IgrADQRB2IAjCDgTBJa4t8OGHHybrg4ODLeqkvRQNrfX09CTrt956a7I+MDCQW7vvvtyTPiVJhw4dStZPRuzZgSAIOxAEYQeCIOxAEIQdCIKwA0EQdiAIxtlbIPJXRae+ZrtonPyGG25I1jdt2pSsX3/99cl6NOzZgSAIOxAEYQeCIOxAEIQdCIKwA0EQdiAIxtnHycwaqknSwoULk/Xly5c31FM7uOWWW5L1O+64I7c2ZcqU5Lrr1q1L1ru6upJ1fBx7diAIwg4EQdiBIAg7EARhB4Ig7EAQhB0IgnH2cXL3hmqSdP755yfrDzzwQLK+Zs2aZP2dd97Jrc2dOze57k033ZSsX3bZZcn69OnTk/W9e/fm1rZs2ZJc96GHHkrWcWIK9+xmdqGZbTOzXWb2hpktz5afbWbPm9mb2e3U6tsF0KjxHMZ/JOmH7v6fkuZK+r6ZfUHSbZK2uvsMSVuzxwDaVGHY3X3Q3bdn94cl7ZJ0gaQFktZmv7ZWUvqcUAC1OqH37GZ2saSZkv4gaZq7D0oj/yCY2Xk563RL6m6uTQDNGnfYzWySpI2SfuDuB4su/jjG3Xsl9WbPkf4kC0BlxjX0Zmaf1kjQ17n709ni/WbWkdU7JA1V0yKAMhTu2W1kF/6opF3uvmpUabOkJZJ+lt2mv9c3sAkTJiTrN998c7Je9JXIBw8ezK3NmDEjuW6zXnrppWR927ZtubU777yz7HaQMJ7D+Csl3STpdTPbkS37sUZC/msz+56kvZK+VU2LAMpQGHZ3/z9JeW/Qv1puOwCqwumyQBCEHQiCsANBEHYgCMIOBGFFl2eWurGT+Ay61KWcTz75ZHLdK664oqltF52t2Mz/w9TlsZK0fv36ZP1k/hrsU5W7j/kHw54dCIKwA0EQdiAIwg4EQdiBIAg7EARhB4JgnL0EHR0dyfrSpUuT9Z6enmS9mXH2+++/P7nu6tWrk/Xdu3cn62g/jLMDwRF2IAjCDgRB2IEgCDsQBGEHgiDsQBCMswOnGMbZgeAIOxAEYQeCIOxAEIQdCIKwA0EQdiCIwrCb2YVmts3MdpnZG2a2PFu+0sz+aWY7sp/51bcLoFGFJ9WYWYekDnffbmafkfSKpIWSvi3pkLvfO+6NcVINULm8k2rGMz/7oKTB7P6wme2SdEG57QGo2gm9ZzeziyXNlPSHbNEyM3vNzNaY2dScdbrNrN/M+pvqFEBTxn1uvJlNkvSCpP9y96fNbJqkA5Jc0k81cqj/3YLn4DAeqFjeYfy4wm5mn5b0W0lb3H3VGPWLJf3W3b9Y8DyEHahYwxfC2MhXmz4qadfooGcf3B3zTUk7m20SQHXG82n8lyT9r6TXJR3NFv9Y0mJJnRo5jN8jaWn2YV7qudizAxVr6jC+LIQdqB7XswPBEXYgCMIOBEHYgSAIOxAEYQeCIOxAEIQdCIKwA0EQdiAIwg4EQdiBIAg7EARhB4Io/MLJkh2Q9PdRj8/NlrWjdu2tXfuS6K1RZfb22bxCS69n/8TGzfrdfXZtDSS0a2/t2pdEb41qVW8cxgNBEHYgiLrD3lvz9lPatbd27Uuit0a1pLda37MDaJ269+wAWoSwA0HUEnYzu8bM/mJmu83stjp6yGNme8zs9Wwa6lrnp8vm0Bsys52jlp1tZs+b2ZvZ7Zhz7NXUW1tM452YZrzW167u6c9b/p7dzCZI+qukr0kakPSypMXu/qeWNpLDzPZImu3utZ+AYWZflnRI0mPHptYys3skvevuP8v+oZzq7j9qk95W6gSn8a6ot7xpxr+jGl+7Mqc/b0Qde/Y5kna7+1vufljSekkLauij7bn7i5LePW7xAklrs/trNfLH0nI5vbUFdx909+3Z/WFJx6YZr/W1S/TVEnWE/QJJ/xj1eEDtNd+7S/q9mb1iZt11NzOGacem2cpuz6u5n+MVTuPdSsdNM942r10j0583q46wjzU1TTuN/13p7pdL+oak72eHqxif1ZI+r5E5AAcl3VdnM9k04xsl/cDdD9bZy2hj9NWS162OsA9IunDU4+mS9tXQx5jcfV92OyTpGY287Wgn+4/NoJvdDtXcz7+5+353P+LuRyX9QjW+dtk04xslrXP3p7PFtb92Y/XVqtetjrC/LGmGmX3OzCZKWiRpcw19fIKZnZV9cCIzO0vS19V+U1FvlrQku79E0qYae/mYdpnGO2+acdX82tU+/bm7t/xH0nyNfCL/N0k/qaOHnL7+Q9Ifs5836u5N0hMaOaz7l0aOiL4n6RxJWyW9md2e3Ua9/UojU3u/ppFgddTU25c08tbwNUk7sp/5db92ib5a8rpxuiwQBGfQAUEQdiAIwg4EQdiBIAg7EARhB4Ig7EAQ/w8+sGPVrnT8WgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "for i in range(5):\n",
    "    # 展示前五章图片\n",
    "    plt.imshow(imgs[i], cmap = 'gray')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\feature_extraction\\text.py:17: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Mapping, defaultdict\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import fetch_mldata\n",
    "# 读取数据集内容,   读取本地 https://blog.csdn.net/qq_34022601/article/details/89645320\n",
    "mnist = fetch_mldata('mnist-original', data_home='./')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'DESCR': 'mldata.org dataset: mnist-original',\n",
       " 'COL_NAMES': ['label', 'data'],\n",
       " 'target': array([0., 0., 0., ..., 9., 9., 9.]),\n",
       " 'data': array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* DESCR 数据集描述\n",
    "* data 包含一个数组，每个实例为一行，每个特征为一列\n",
    "* target 包含一个带有标签的数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 根据获得数据标签划分标签和训练数据\n",
    "X, y = mnist['data'], mnist['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000, 784)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 7w  6w的训练 1w的测试，7w个 784个数据\n",
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(28, 28)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随意取一个下标，并划分成图片大小\n",
    "some_digit = X[12345]\n",
    "# 784个数据，变成行和列\n",
    "some_digit_image = some_digit.reshape(28, 28)\n",
    "some_digit_image.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(some_digit_image, cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看该下标的结果\n",
    "y[12345]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立测试集和训练集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练集 和 测试集 训练标签，测试标签\n",
    "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30950, 17218, 41872, ..., 39301, 57404, 27595])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将数据集合交叉洗牌，交叉验证时，每个子集合数据分布均匀，有些机器学习算法对训练实例的顺序敏感\n",
    "import numpy as np\n",
    "# 6w下标，随机排列\n",
    "shuffle_index = np.random.permutation(60000)\n",
    "shuffle_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练集和训练标签洗牌，然后赋值\n",
    "X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练一个二元分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 识别数字5 ，二元分类5或者非5\n",
    "# 创建目标向量 判断true  false\n",
    "y_train_5 = (y_train == 5)\n",
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True, False, False, ..., False,  True, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ...,  True, False, False],\n",
       "       ...,\n",
       "       [ True, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# -1在这里应该可以理解为一个正整数通配符，它代替任何整数。我不知道有多少列，numpy会自动帮我计算\n",
    "y_train_5.reshape(20, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 测试集 也拿出5或者 非5\n",
    "y_test_5 = (y_test == 5) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SGD 梯度下降 分类器， 适合非常大的数据集，独立处理训练集数据，一次一个，适合在线学习，\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "# 随机种子，每次的值一直\n",
    "sgd_clf = SGDClassifier(random_state = 5)\n",
    "# 标签为5的 数据\n",
    "sgd_clf.fit(X_train, y_train_5)\n",
    "# 预测 somedigit  我设置的1\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 性能考核"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用交叉验证测量精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.9551 , 0.96095, 0.9587 ])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器比评估回归器要困难得多\n",
    "\n",
    "# 3个折叠，正确率达到 95% 以上\n",
    "from sklearn.model_selection import cross_val_score\n",
    "# 交叉验证 cv 测试次数 \n",
    "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把每张图都分类成 非5\n",
    "from sklearn.base import BaseEstimator\n",
    "# 估算器 ，评估非5\n",
    "class Never5Classifier(BaseEstimator):\n",
    "    def fit(self, X, y=None):\n",
    "        pass\n",
    "    def predict(self, X):\n",
    "        # 初始化 矩阵，标签就是 5或者非5\n",
    "        return np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False],\n",
       "       [False],\n",
       "       [False],\n",
       "       ...,\n",
       "       [False],\n",
       "       [False],\n",
       "       [False]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 二维矩阵，非5评估，所以全为false\n",
    "np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.9089 , 0.91095, 0.9091 ])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 分类器，\n",
    "never_5_clf = Never5Classifier()\n",
    "# 交叉验证\n",
    "cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 准确率超过90% ，因为5的图像大约只有10%，你猜一张图不是5， 90%的时间你都是正确的\n",
    "* 这说明准确率无法成为分类器的首要性能指标，特别是当你处理偏科数据集， 某些类比其他类更为频繁"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 混淆矩阵"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 在混淆矩阵中，一个轴表示模型预测的标签，另一个轴表示实际标签。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 评估分类器性能的更好方法是混淆矩阵\n",
    "# A类别实例被分为B类别次数\n",
    "# 想要知道分类器将数字3和数字5混淆多少次，通过混淆矩阵的5行3列\n",
    "from sklearn.model_selection import cross_val_predict\n",
    "# 预测结果\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 与 cross_val_score 相比\n",
    "* 同样执行交叉验证\n",
    "* 返回的不是评估分数，是每个折叠的预测\n",
    "* 每一个实例在模型预测时使用的数据，在训练期间从未见过"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[53973,   606],\n",
       "       [ 1899,  3522]], dtype=int64)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "# 混淆\n",
    "confusion_matrix(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "* 行表示实际类别，列表示预测类别\n",
    "* 第一行 第一列 53272 被正确的分为 非5 ，真负类\n",
    "* 第一行 第二列 1307 被错误的分类成 5 ，假正类\n",
    "* 第二行 第一列 1077 张被错误的分为 非5， 假负类\n",
    "* 第二行 第二列 4344 张被正确的分在了5 ，真正类\n",
    "* 这种衡量方式太复杂，我们可以用更简单的指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54579,     0],\n",
       "       [    0,  5421]], dtype=int64)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 实际的预测标签，完美预测  实际==预测\n",
    "y_train_perfect_predictions = y_train_5\n",
    "confusion_matrix(y_train_5, y_train_perfect_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## 正类预测的准确率 被称为分类器的精度\n",
    "\n",
    "\n",
    "$\n",
    "\\text{精度} = \\cfrac{TP}{TP + FP}\n",
    "$\n",
    "\n",
    "TP是真正类的数量，FP是假正类的数量\n",
    "\n",
    "\n",
    "\n",
    "$\n",
    "\\text{召回率TPR} = \\cfrac{TP}{TP + FN}\n",
    "$\n",
    "* 检测正类实例的比例\n",
    "* FN是假负类的数量\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度和召回率\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8531976744186046"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score\n",
    "# 实际标签和交叉验证的预测标签，获得精度\n",
    "precision_score(y_train_5, y_train_pred) # 4327 / 4327 + 1276"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6496956281128943"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 获得召回\n",
    "recall_score(y_train_5, y_train_pred)    #  4327 / 4327 + 1094"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "* 说明 检测一张图的时候，只有90%的概率是准确的，而且只有64%的数字5 被它检测出来\n",
    "* 精度和召回率合成单一指标，成为 F1 分数，谐波平均值\n",
    "* 平均值平等对待所有的值，谐波平均值会给予较低值更高的权重，只有召回率和精度都很高时，才能获得较高的F1分数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7376688658498273"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "# f1分数\n",
    "f1_score(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "* F1分数对那些具有相近精度和召回率 分类器更有利，这不一定符合你的期望\n",
    "* 有时候你更关心精度，有时你能关心召回率\n",
    "* 训练一个分类器检测儿童可以放心观看的视频，你可能要求拦截了很多好的视频，低召回率，保留下来的都是安全的视频，高精度\n",
    "* 不能同时增加精度并减少召回率，反之亦然  。。高召回 低精度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度/召回率权衡"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* SGDClassifier对每个实例基于决策函数计算一个分值，大于阀值为正类，否则为负类\n",
    "* 中间阀值右侧找到4个真正类 真5 ， 一个假正类 6， 精度为 4/5 80%\n",
    "* 在所有的6个 真正的5 中，分类器找到了4个，召回率为 4/6 67%\n",
    "* 提高阀值，向右移动，精度提高，召回降低\n",
    "* 反之阀值降低，召回提高，精度降低\n",
    "* SKlearn不可以直接设置阀值，可以访问决策分数，\n",
    "* SGDClassifier 默认阀值为0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-80438.59182758])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回决策值decision_function  决策值分数\n",
    "y_scores = sgd_clf.decision_function([some_digit])\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 默认阈值为0\n",
    "threshold = 0\n",
    "y_some_digit_pred = (y_scores > threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提高阀值可以降低召回率，提高阀值到200000，就错了这个图\n",
    "threshold = 200000\n",
    "y_some_digit_pred = (y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 如何决定使用什么阀值\n",
    "# 返回决策值，而不是预测结果\n",
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,\n",
    "                             method=\"decision_function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000,)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 有了y_scores，可以计算所有可能的阀值的精度和召回率\n",
    "y_scores.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "# 计算 精度 召回 阈值\n",
    "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib 绘制精度和召回相对于阀值的函数图\n",
    "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n",
    "    plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precision\", linewidth=2)\n",
    "    plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n",
    "    plt.xlabel(\"Threshold\", fontsize=16)\n",
    "    plt.legend(loc=\"upper left\", fontsize=16)\n",
    "    plt.ylim([0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n",
    "plt.xlim([-700000, 700000])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf0AAAF5CAYAAACV7fNGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3dd5gV5fn/8c+9C0vvTQ0QBUHBKBg3CrGtYmyJGlGxF4yaGEv0G5NovpgYazSxEA02sMaoGKNJ/MlXY40aLIuKBSuKIoqhSROQcv/+eM5mzi5bzu6eM3PK+3Vd55pnzplz5mbg4jPzzMwz5u4CAADFryzpAgAAQDwIfQAASgShDwBAiSD0AQAoEYQ+AAAlgtAHAKBEEPoAAJSI2EPfzPqZ2TNNLDPFzKab2YS46gIAoNjFGvpm1kPS7ZI6NbLMWEnl7j5a0iAzGxJXfQAAFLO4j/TXSzpc0rJGlqmSNDXVflTSLjmuCQCAktAmzpW5+zJJMrPGFuskaV6qvVjSN+suYGanSDolzPXaQdpcfftKAwZks1oAAPLTjBkzFrp7n+Z+L9bQz9AKSR1S7c6qpzfC3W+SdJMkDRhQ6Z98Uq2jjpKuvjq+IgEASIqZfdSS7+Xj1fszFHXpj5A0J7lSpPXrpffek557Tlq7NslKAABonUSP9M1suKSj3D39Kv0HJT1jZptJ2k/SqDhrmjNHeuop6d//lmbOlN54Q/ryy/BZv37SfvtJZ5whfXOjkw4AAOS3RELf3atS01mSJtT5bJmZVUn6jqQr3H1pLmtZv17617+kqVOladOkjxrpMPn8c+m226QVK6TTT5dmzJA++0w66yzpa1/LZZUbW7dOWr5c6tEj3vUCAApXPp7Tl7svUXQFf0785z/S9ddLN9wgzZ8fvd+9u7T77tJuu4Wj+W23DUf6F10kPfpo2Cn4y1/Cq8bvfy9ddZX06qvSyy+H3oG335a22irzer76SqqoCG33sIPxwQfS3LnSJ59Er5r5efOi7/7qV9JvftO8P797mDZ+TWW07LJl0oIF0Wv+fGmXXaThw5u3XgBAcsxr/vcvUDUX8p11VmYX8i1fLl1yiXTNNdKaNeG9wYOlceOkQw6RRo6Uysvr/+5rr0nbby+1aRN2Bj7+OARgQz78UNp889rvLVwovfmm9NZb0WvWrCjEt9tOmj1bWrmy6T9LXTvsIF1wQdgx+OADqXdvadNNpU8/3fj12WdhR2Pw4LA+KfRemNUO9wULQs0NXc/Qo0fo5fjoI+n++8O2Wbgwer37rrTrrtKwYVLfvtLXvy61b9/8PxsAIGJmM9y9stnfK5bQHz9e+uUvpS23DEem9R3BPvaYdNxxIfAk6YADpLPPlqqqMjvilcJOQ7t20VH52WdLzzwTegW++U2pulqaMiVa/sEHQ7C/9FL47OOPM1tPjx4hkAcODLci9u8fXjXtTTcN1xzsuGNmv9danTtLffqEV1mZ9PzzLf+tXr2kSZPCn2/RorBzsGhR9Eqff/llafTosI3LysLfk3v4e+jcObwHAKWm5EO/xptvSocfLm2zjXTPPdFyl18unXdeCIwdd5SuvTZ3gXnJJdKEBgYQ7tQp1DZsWHgNHx6m770nLV0adloGD878XP2aNeGiwz33lIYMkQYNkjbbTLr11rAzs9lm9b/atQvr7NpV+vvfwymJoUOjYO/TJxyZ9+kTegw6dKi93mXLwk5Ux45hO997b1h3797R6/XXwymPjh1DgGdLeXm4FqPGxReHnaNFi8JnNT0WAFCsCP2UbbcNYSNF560nTAhBbBbOf59/fsNd+Nly/PHSffdJI0ZI3/qWVFkZXlttlft156t166RTT5UmTw69FTU7B716hVfddps20sEHh6P6lhoyRNp779ArsPXWYcdq773DDsIXX4QdoOHDOeUAoLAQ+vVwl268UfrRj0LQ3nmndOSR8dXW0GkGNM+SJeF0yqefSl26SD17hm79Rx6RDj00XHjZq5f05z+3fl3DhoX11Vzc+bOfhWszDj889MD07Bl6Pfr2bf26AKClCP16jBsn/fWv4QjzttvC0TeK2+LF4cLEv/0t3HXxl7+EUxjduoXTIFI4jfHuu6EnYd26lq9r7Nhw6mLBgrADcthhoTfhyCPDmA49e2bnzwQAdRH6jTj11HDhGFDXqlXhNWdO6PLv2zdcd3HOOeH9t94Kd0O01Jtvhp2C4cPD9REAkA2EfoOfh/94u3SJsSgUrQ0bwoWLL7wQLh7s3TuM37B0qfTPf4bbIJuy//7h+o42bcI1BZ9+Kp12Wvg32rZt7v8MAAofoZ/m7LOje/bp1kfcNmyILtZs315avbp53z/ppHDB54gR0l57cV0IgI21NPTzckS+5tiwofb8jjvWHiXu6KPjrQcoK4vuHJHCbZXV1dIf/xhOFbz+ergwcfvtQy9BXZMn1/+7vXuHaxEYehlASxV86NftTq2slI44Qnr22XDE1Kbg/4QodO3aSTvvHF71cQ8XFN5yi3T77dL06dEgROkWLowuDhwzJpxOoBcAQHMUfPd+9+6VvnRp1L3/8svhCAoodPPnh6Gf584NO7AN2WOP0IswbFh8tQFIVsme0+/cudJXrgyh/8474XYsoBgtWRJGlbzxxsyWHzQonFq47rpwgeAnn4RTX7vsQg8BUOhKNvQ7dKj01atD6Bf4HwXI2LJl0plnhvEB0p8S2VwHHRSe4XD88dKJJ4adAbMwYiKA/FWyob/11pW+cGG1Jk0Kg/EApWjtWun998PpgGefDcMP/+Qn4bPhw8OTHJtrypSwIwAg/5Rs6FdWVvpLL1XTXQlkwD10819wQWi/8040UmG7dtHjpus67TRp1Kiwc/HZZ+F2wn33Ld3nSABJK+nQr65ufEQ+AJlxD4+DHjs28+9ssol04IFhJ6B//7AjsP32XDcA5BKhDyBr3MPwwc8+Kz3wgPTRR+GhRp9/Hm4pzMShh0pXXhlGLgSQXYQ+gFjNnRt6Be65J5wiGDw4POyorm7dQm/AbbeFUwQAWq+loV+Wi2IAFL8BA6QzzpCeey70DLz/fph+/LG0997RckuXhmsHRo8OXf5bbBGeRtjQyIMAcofQB5BVAwaEWwnXr5deeSVc9JduzpywE3DyyWEn4OSTW3Z3AYDmI/QB5ERZmTRypPTqq6EHYOFC6b77pB/+sPZykydL22wTdgB69ZIuvTS6owBAdnFOH0DsNmyQbrhBuvnmsFPQkFGjwiibU6bwHA0gHef0ARSMsjLpxz8O3f811wOMHx/O9ad7/nnpjjvCMMLf+179FwoCyByhDyBxgweHpwy+9VY0aNAxx9Re5v/9P2nLLcPdALfemkydQKEj9AHknaFDpTvvDDsAc+eGe/5rLFsWPSfg+9+XLrlEuv765GoFCgnn9AEUBPfQ3f/tbze8zMSJ0qmnhtMBQDHjnD6AomYW7vVfuVI666xwTcCRR9Ze5ic/kSoqwrLnnBNOCQCIcKQPoODdf3/tUwB1ffZZGBUQKBYc6QMoWYccErr/P/hA2muvcL9/uk03DUf/I0dKt98ebhkEShGhD6BobLGF9M9/hoGA3KUzz6z9+cyZ0gknhCcBlpVJr78elgNKBaEPoGhNnBhC/dlnpfbta3/mLm23XQh/M+nee5OpEYgToQ+g6O28s7RqVQj6L76QLrxw42WOOCKE/8SJ0rx58dcIxIHQB1BSunWTzj8/7ABs2CBdc03tz886S+rfP+wAzJ+fTI1ArhD6AEqWWbjNzz1079cdBnjTTaWnnkqkNCAnCH0AkDRuXDQM8MMPR+/vsYfUsWM4PQAUOkIfAOrYbz/p6aej+VWrQvCbScuXJ1cX0FqEPgDUY7fdwq1/dXXtuvHDgIBCQegDQAN69Qrd/dOn137/rrukk05KpiagNQh9AGjCqFEh/FesiN6bMiV09//iF8nVBTQXoQ8AGerUSfrww9rvXXFFeP+hhxjeF/mP0AeAZth883DUv2xZ9N6XX0oHHBCG933wQWn27MTKAxpF6ANAC3TpIq1bF271S3fwwdKWW4au/08+SaY2oCGEPgC0UHl5GNTHPQzfW9eAAWEngG5/5AtCHwCy4MwzN+72l0J3f3l5OPIfP1564olk6gMkQh8AsqpLlxD+9T2057bbpDFjpJEjpbVrYy8NIPQBIBc22yyE/1dfSRdfLP3sZ9FnM2dKFRXh6P/FF5OrEaXH3D3pGlqlsrLSq6urky4DAJq0Zo3Uvv3G7++wg8R/Y2gOM5vh7pXN/R5H+gAQk3btwtH/mjXSDTdE78+YIQ0dGj4DconQB4CYVVRIP/xh7fP6770nlZVJxx8vPf54crWhuBH6AJCQNm3Cvf7p7rhD2muvcL5/7NiN7wYAWoPQB4AElZeHbv3Jk6XOnWt/9sADUrduYQdgp52kJUuSqRHFg9AHgDzwgx9Iy5eHHYCHHpI6dqz9+YsvSj17btwzADQHoQ8Aeea735VWrgw7AH/9qzR4cPRZ27YM8IOWI/QBII8dfLD0/vvSCSdE740ZI40enVhJKGCEPgAUgFtvlf7wh2j++efDuX6e6IfmiD30zWyKmU03swkNfN7DzB42s2ozuzHu+gAgX51xRnh4T0VF9N6WW0qXXppcTSgssYa+mY2VVO7uoyUNMrMh9Sx2rKS7UiMNdTGzZo84BADFykxavTrc2lfjf/83vM94/mhK3Ef6VZKmptqPStqlnmUWSfqGmXWXNEDS3HhKA4DCYCYde6y0cGHt9ysquK0PjYs79DtJqnn21GJJ/epZ5llJX5d0pqS3UsvVYmanpLr/qxcsWJCrWgEgr/XqFbr7R46M3uvZU/r00+RqQn6LO/RXSOqQanduYP2/lvQjd79Q0tuSxtddwN1vcvdKd6/s06dPzooFgHxnJr3yinTIIdF7X/uadM89ydWE/BV36M9Q1KU/QtKcepbpIWlbMyuXtJMkHkEBAE34y1+k3/8+mj/yyDDADw/xQbq4Q/9BScea2VWSxkl608wurrPMZZJukrRUUk9Jd8dbIgAUpp/+VJo5M5pftSo8xGf58uRqQn6JNfTdfZnCxXzPS9rD3We6+4Q6y7zo7tu4e2d3/467r4izRgAoZNttF47uL7wwem/zzRMrB3km9vv03X2Ju0919/lxrxsASsX554fR/CRp8WJpxx2TrQf5gRH5AKBITZ0atV96KYzbzzn+0kboA0CRatOm9i1969aFc/wzZiRbF5JD6ANAEau5pa+qKnqvslKay7BnJYnQB4AS8OST0vTp0fzAgdKsWcnVg2QQ+gBQIkaNki6/PJrfZhvpqKOSqwfxI/QBoIT8/Oe1H9Zz993SnnuGh/ig+BH6AFBijj1W+uKLaP7JJ6UOHaQPP0yuJsSD0AeAEtStm7RsmdS+ffTeoEHhwr9Fi5KrC7lF6ANAierSJQzVO21a7fd795Zeey2ZmpBbhD4AlLh995Vmzw738NcYMUK6//7kakJuEPoAAA0aJK1fLz39dPTeoYdKRxyRXE3IPkIfAPBfu+0mvftuNH/vveE8/xNPJFcTsofQBwDUMmSItKLO803HjKndC4DCROgDADbSqVN4OE/6RX5VVTywp9AR+gCABu27r/T889F8jx7J1YLWI/QBAI3aaSfpzDNDe+nScI5/5cpka0LLEPoAgCZNnChtvXU037mzdMMNydWDliH0AQAZmTVLatcumj/11HDUz3n+wkHoAwAyYhYezPPqq7XfHzo0mXrQfIQ+AKBZRoyQ1qyJ5t9/X1q+PLl6kDlCHwDQbBUVtbv1t9oquVqQOUIfANBiJ58cpp99Jp11VrK1oGmEPgCgxdKv4J84ceMn9iG/EPoAgBYrK5MWLozm999f+tvfkqsHjSP0AQCt0qtX7Sv6v/99ae7c5OpBwwh9AECrjRhRe7jegQOld95Jrh7Uj9AHAGTFTjtJd94ZzW+9de0dASSP0AcAZM0xx0j33x/Nf+97ydWCjRH6AICsGjtWuvba0F60SFq3Ltl6ECH0AQBZd+KJUbttW+m115KrBRFCHwCQdR07SpdcEs2PGCFddlly9SAg9AEAOfHLX0rPPVd7/umnk6sHhD4AIIe+/W1p6dJovqoq3M6HZBD6AICc6tpVevzxaH7uXGmTTZKrp5QR+gCAnNtzT+mrr6L5zz+XXnwxuXpKFaEPAIhF27bShg3R/E471X48L3KP0AcAxMZM+te/ovkyUihWbG4AQKx23VXadNNofuzY5GopNYQ+ACB28+ZF7QcekO66K7laSgmhDwCInZm0Zk00f8wx0vvvJ1dPqSD0AQCJqKiofcQ/ZIg0ZUpy9ZQCQh8AkJjNNpMeeyyaP+kkafr05OopdoQ+ACBRY8bUHrXv29+WZs1Krp5iRugDABLXtWvtI/xttuGRvLlA6AMA8sKoUdLf/x7N1x3MB61H6AMA8sYBB0jnnRfNl5dLc+YkVk7RIfQBAHnl0kul8eOj+crK5GopNoQ+ACDv3HKL9JOfhPaiRdILLyRbT7Eg9AEAeemKK6L2qFHS8uXJ1VIsCH0AQF6qqJCmTYvmu3blqXytRegDAPLWvvvWfiAPT+VrHTYfACCv3X+/tMkm0bxZcrUUOkIfAJD3PvtM2nnnaJ7gbxlCHwBQEJ59tvb8G28kU0chI/QBAAVj9eqove22ydVRqAh9AEDBaNdOmjgxmp89O7laClHsoW9mU8xsuplNaGK5SWZ2QFx1AQAKw+mnR+0zzkiujkIUa+ib2VhJ5e4+WtIgMxvSwHK7StrE3f8RZ30AgPxXViaddlpoT5smffBBsvUUkriP9KskTU21H5W0S90FzKytpJslzTGzg+IrDQBQKC66KGoPHixtsUVytRSSuEO/k6R5qfZiSf3qWeY4SbMkXSFpRzPbqPPGzE4xs2ozq16wYEHOigUA5KcePaSnnorm58yRbr89qWoKR9yhv0JSh1S7cwPr317STe4+X9KfJO1RdwF3v8ndK929sk+fPjkrFgCQv3bfXVq/Ppo/4QSG6W1K3KE/Q1GX/ghJc+pZ5n1Jg1LtSkkf5b4sAEAhKiuT3nknmj///ORqKQTmMe4WmVlXSc9IelzSfpKOkHSYu09IW6aLpFsUuv7bSjrU3efV83OSpMrKSq+urs5p3QCA/DZwoDR3bmgvWiT17JlsPblmZjPcvbK534v1SN/dlylczPe8pD3cfWZ64KeWWe7uh7n7bu4+urHABwBAkh57LGofeGBydeS72O/Td/cl7j41dc4eAIBWGzpUOvzw0H7uudrn+hFhRD4AQFH4wx+i9vHHJ1dHPiP0AQBFoW9faautQvuuu5KtJV8R+gCAopF+tP/EE8nVka8IfQBA0Rgzpnb7hReSqyUfEfoAgKJRXi59lDa6y6hRydWSjwh9AEBRGThQuueeaH7KlORqyTeEPgCg6IwbF7V/85vk6sg3hD4AoOiYRQ/gmTtXWr062XryBaEPAChKRx0Vte+4I7k68gmhDwAoSm3aSCNGhPYPf5hsLfmC0AcAFK30i/geeii5OvIFoQ8AKFo77BC1DzgguTryBaEPAChq6efz58xJrIy8kPXQN7MO2f5NAABa6thjo/YWWyRXRz5oMvTNrMLMdk21y82sqQ6Si8zswqxUBwBAFtxyS9Resya5OpKWyZF+T0mPpdptJN3TyLKStKmk7q0pCgCAbBo/vv52qckk9NekXnL3NZLWpX9oZneZWbe0tzaV9FrWKgQAIAtquvbvvlv6xS+SrSUpmYT+BknrzexmM1suqbOZLTGz5Wb2HUlHSnrDzL6VWn6EpOk5qhcAgBZ5772ofcUVydWRpOZcyDdR0kGSVkr6vqRXU99fKul8Sf9nZj+TtMrd38x2oQAAtEZ5ubRoUTR/YQlefZZJ6O8uyd39DXd/QtI6d39a0sLU5+7ut0k6XtJlkv6ck0oBAGilnj2lLl1C+9e/TraWJDQa+mb2V0kPZvhbO6Wm7VpVEQAAOTR1atQ+88zk6khCU0f610mqkiQzG21m4yVVmNlxkgaklmljZpMlHSZpjKRDzcxyVC8AAK2yzz5Sx46hfe210pIlydYTpzaNfejuT6SuzDeF8D9C4Uj+p5LaSlotqXPq8x3dfZmZzZO0m6Snc1g3AAAtYib95z9S585hvmdPyT3ZmuKS6YV87u6XSdpe0pfuPsLdhytcpf+lu//A3Zelln1K0ujslwoAQHZ06iTdeGM0//bbydUSp+YOw9teUvowuybp3jrLvCFpBwEAkMdOOSVqDxsmrVyZXC1xabR7P007Mzs91T7LzE6S9KWkzyRdYWad3X1F6vPZku7Lcp0AAGTd//2ftO++of21r0lffJFsPbmWSeivl/S2pKMl1Zz1aCOpU+q1iaS2ZvaupEcl3eLuU+v7IQAA8sk++0hnnBEu6Fu6NAza8/OfJ11V7phn4eoFMxsoaU+FC/2+I2k3d3+u1T+cgcrKSq+uro5jVQCAIrR2rVRREc0XwkV9ZjbD3Sub+71mP1rXzPqYWe/099z9Y3e/zd33lTQirsAHAKC12raV5s6N5q+7Lrlaci2TR+t2MLOfWtBe0smSjmtoeXd/I5sFAgCQa/37S336hPYZZyRbSy5leqR/tqRvSJqkcG/+V2Y2w8w+MbMP6rzeMbMLclUwAAC5MG1a1F6/Prk6cqnJ0Hf3VZLWKoT9aoVH666V1EPh4r4OksanTd+QdI6ZleeoZgAAsm6HtJvNi/XRu02Nvb+fme2hMApfpaR+kras+Tz14J1Vqenq1PRKSQcqPJIXAICC0a9fmF55ZbJ15EpTR/p3SrpDUh9JV0jaS9JRjX3B3f/t7k94Nm4LAAAgRk+nDSB/663J1ZErjYa+u/d29wGSPlEYe/8OSRc1tHh2SwMAIF5bbRW1TzstuTpyJZOr98sVBuMpk1ShMPRuWfjIfiWpR/q05pXLogEAyJU//jFMV61Kto5cyOTq/fap10pJL6baFQpj7vdTOAXQQ6EXoHfqvYG5KBYAgFw7+uiovXhxcnXkQpPD8Lr7SjP7saSv3H2KmR0m6QN3n2FmP5A02N1/mfNKAQCIQbduUfu666RfFVHfdab36R8p6X0zO0LSPZJmmdltks6V9HiOagMAIBE15/Z//etk68i2Ro/0zexwhXvzb1e4/35Y6qN9JH2hcFFfJzM7MO1r5Qq3+N3n7kU6vAEAoJjdcIO0xx6hvW6d1CbTZ9Lmuab+GBdIWqNwZb4rXMRnku5PfT5b0orUe+m/2U7SQ6nPAAAoKFVVUbtt28J4CE8mmrplb5i7j5S0m6Tpkn6hEP6HSnpYUndJd0uqdPftU69t3X2ouxP4AICClT5C3+zZydWRTZme05+qcFX+LIWj+kfc/QBJ+0s6XNJzZmaNfB8AgIKS/tT2LbeUNhTBOLOZhv4J7n6ou38iaQt3/1KS3L1a0ihJ/8MIfACAYvPww1G7vAieKJNR6Lv752ntj+p8ts7d/53twgAASNp++0mbbJJ0FdmT6ZE+AAAl6aWXovb8+cnVkQ2EPgAAjejfP2pPmpRcHdlA6AMA0ISaW/hefDHRMlqN0AcAoAljx4bpI48kW0drEfoAADRhn32i9urVydXRWoQ+AABNGDo0ahfyA3gIfQAAMtC7d5j+7nfJ1tEahD4AABmYODFqF+pwdIQ+AAAZOPLIqL1oUXJ1tAahDwBABsykvn1D+/TTk62lpQh9AAAytPPOYXrvvcnW0VKxh76ZTTGz6WY2oYnl+pnZK3HVBQBAU268MWovWJBcHS0Va+ib2VhJ5e4+WtIgMxvSyOK/l9QhnsoAAGhanz5R+7LLkqujpeI+0q+SNDXVflTSLvUtZGZ7SlopqcAfbQAAKDZjxoTp1VcX3lX8cYd+J0nzUu3FkvrVXcDMKiSdL+nchn7EzE4xs2ozq15QiP0rAICCddFFUXv06OTqaIm4Q3+Foi77zg2s/1xJk9z9i4Z+xN1vcvdKd6/sk97XAgBAjo0eLfXsGdovvCB9+WWy9TRH3KE/Q1GX/ghJc+pZZi9Jp5nZU5JGmtnkeEoDACAzn3wStf/2t+TqaK64Q/9BScea2VWSxkl608wuTl/A3Xdz9yp3r5L0qrufFHONAAA0qkOHqGv/9tuTraU5Yg19d1+mcDHf85L2cPeZ7t7grXup4AcAIO9svnmYrlmTaBnNEvt9+u6+xN2nujtX5gMACtbBB4fp3LnJ1tEcjMgHAEAL9OoVprNnJ1tHcxD6AAC0wKhRUfu++5KrozkIfQAAWqBjx6h99NHJ1dEchD4AAC10zTVhunZtsnVkitAHAKCFTj01as+Zk1gZGSP0AQBooYqKqH3eecnVkSlCHwCAVthnnzB94YVk68gEoQ8AQCuMHx+mH36YbB2ZIPQBAGiFmkftStJddyVXRyYIfQAAWqF376h9zDHJ1ZEJQh8AgFZKf+jOk08mV0dTCH0AAFop/Qh/3Ljk6mgKoQ8AQCuVlUmXXx7aCxdK7snW0xBCHwCALDj77Kidr2PxE/oAAGRB27ZS9+6hfffdydbSEEIfAIAsqRmV78EHk62jIYQ+AABZcuKJUXvu3OTqaAihDwBAlqTfs3/cccnV0RBCHwCALKoJ+6eeku6/P9FSNkLoAwCQRTffLPXrF9qHHipt2JBsPekIfQAAsqiiQpo2LZqveSBPPiD0AQDIsu23l77+9dC+445ka0lH6AMAkAOPPBK1581Lro50hD4AADmw1VZShw6h/bvfJVtLDUIfAIAc2XXXMJ04Mdk6ahD6AADkyIQJUXvVquTqqEHoAwCQIzVH+pJ06aXJ1VGD0AcAIIe23jpML7442TokQh8AgJy66KKonfRAPYQ+AAA5dNBBUTvpC/oIfQAAcqhtW2nYsNC+885kayH0AQDIsZ/+NExfeSXZOgh9AABy7Mgjo/bnnydXB6EPAECOdewYtd94I7k6CH0AAGLQq1eYPvZYcjUQ+gAAxKCqKkx/+9vkaiD0AQCIwRFHRO01a5KpgdAHACAGhxwStS+4IJkaCH0AAGJgJu2+e2jPm5dMDYQ+AAAxOeqoMF29Opn1E/oAAMSkW7cwfeSRZNZP6AMAEJNttgnTZcukJUviXz+hDwBATGpCX/UImHsAAApTSURBVJLmzIl//YQ+AAAxMZN23TW077kn/vUT+gAAxGjVqjD9xz/iXzehDwBAjM47L0zfekvasCHedRP6AADE6Hvfi9pdu8a7bkIfAIAYVVRIZ54Z2itXSu7xrZvQBwAgZldcEbWvuiq+9RL6AADErF07qUOH0D7nnPiO9gl9AAAS8O67UXv58njWSegDAJCA/v2jYXm/+iqedRL6AAAkpGPHMK25dz/XCH0AABLSvXuYjh0bz/oIfQAAErJ2bZhWV8ezPkIfAICEPP541I7jCn5CHwCAhAwcGLUfeyz364s99M1siplNN7MJDXzezcymmdmjZvaAmVXEXSMAAHFp2zZM04/6cyXW0DezsZLK3X20pEFmNqSexY6WdJW77y1pvqR946wRAIA4HX54mH7+ee7XFfeRfpWkqan2o5J2qbuAu09y93+mZvtI+k88pQEAEL+99grT227L/VP34g79TpLmpdqLJfVraEEzGy2ph7s/X89np5hZtZlVL1iwIDeVAgAQg4MOitpPP53bdcUd+iskpUYbVueG1m9mPSVdK+nE+j5395vcvdLdK/v06ZOTQgEAiEPNvfqS9MgjuV1X3KE/Q1GX/ghJc+oukLpw7z5J57n7R/GVBgBAMo4+OkxnzMjteuIO/QclHWtmV0kaJ+lNM7u4zjI/kPRNSf9rZk+Z2eEx1wgAQKz23DNMc33bXpvc/nxt7r7MzKokfUfSFe4+X9LMOstcL+n6OOsCACBJO+8ctdesCY/ezYXY79N39yXuPjUV+AAAlLyhQ6P2W2/lbj2MyAcAQMLMpMrK0H7vvdyth9AHACAP9O8fpuPG5W4dhD4AAHng7LOj9urVuVkHoQ8AQB7Yddeo/eijuVkHoQ8AQB4wk77xjdA+/vjcrIPQBwAgTxx4YJh+8UVufp/QBwAgT9SMzCdJt96a/d8n9AEAyBPDh0ft667L/u8T+gAA5JHf/jZM581rfLmWIPQBAMgj++8fpp9/Lq1bl93fJvQBAMgjNVfwS7Xv3c8GQh8AgDxiJm29dWgvWpTd3yb0AQDIM5deGqZ3353d3yX0AQDIM5tvnpvfJfQBAMgzI0dG7csvz97vEvoAAOQZs6h97rnZ+11CHwCAPPTCC9n/TUIfAIA8tN12UftPf8rObxL6AADkofbto/bVV2fnNwl9AADy1OTJYfryy9n5PUIfAIA8dcghUTsbj9sl9AEAyFPdu0ftP/+59b9H6AMAUACycV6f0AcAII9dc02YLl7c+t8i9AEAyGPf/W6YLl4s/fvfrfstQh8AgDw2eHDU3nnn1v0WoQ8AQB4zkx56KJq/776W/xahDwBAnvvud6W+fUN73LiW/w6hDwBAAXjlldb/BqEPAEAB2Gwz6X/+p3W/QegDAFAgrrxSmjWr5d8n9AEAKCDDhrX8u4Q+AAAlgtAHAKBEEPoAAJQIQh8AgBJB6AMAUCIIfQAASgShDwBAiSD0AQAoEYQ+AAAlgtAHAKBEEPoAAJQIQh8AgBJB6AMAUCIIfQAASgShDwBAiSD0AQAoEYQ+AAAlgtAHAKBEEPoAAJQIQh8AgBJB6AMAUCIIfQAASgShDwBAiSD0AQAoEbGHvplNMbPpZjahNcsAAIDmiTX0zWyspHJ3Hy1pkJkNackyAACg+eI+0q+SNDXVflTSLi1cBgAANFObmNfXSdK8VHuxpG+2ZBkzO0XSKanZNWb2RpbrxMZ6S1qYdBFFjm2ce2zj3GMbx2Orlnwp7tBfIalDqt1Z9fc0NLmMu98k6SZJMrNqd6/MfqlIx3bOPbZx7rGNc49tHA8zq27J9+Lu3p+hqLt+hKQ5LVwGAAA0U9xH+g9KesbMNpO0n6QjzOxid5/QyDKjYq4RAICiFOuRvrsvU7hQ73lJe7j7zDqBX98yS5v42ZtyUCo2xnbOPbZx7rGNc49tHI8WbWdz92wXAgAA8hAj8gEAUCIKJvQZyS/3mtp+ZtbNzKaZ2aNm9oCZVcRdYzHI9N+pmfUzs1fiqquYNGMbTzKzA+Kqq5hk8P9FDzN72MyqzezGuOsrFqn/B55pYpmMs68gQp+R/HIvw+13tKSr3H1vSfMl7RtnjcWgmf9Of6/o9lVkKNNtbGa7StrE3f8Ra4FFIMNtfKyku1K373UxM27jayYz6yHpdoXxaxpaplnZVxChL0byi0OVmth+7j7J3f+Zmu0j6T/xlFZUqpTBv1Mz21PSSoWdKzRPlZrYxmbWVtLNkuaY2UHxlVY0qtT0v+NFkr5hZt0lDZA0N57Sisp6SYdLWtbIMlVqRvYVSujXHaWvXwuXQcMy3n5mNlpSD3d/Po7CikyT2zl12uR8SefGWFcxyeTf8nGSZkm6QtKOZnZGTLUVi0y28bOSvi7pTElvpZZDM7j7sgzuYGtW9hVK6GdlJD80KqPtZ2Y9JV0r6cSY6io2mWzncyVNcvcvYququGSyjbeXdJO7z5f0J0l7xFRbschkG/9a0o/c/UJJb0saH1NtpaZZ2VcowchIfrnX5PZLHYHeJ+k8d/8ovtKKSib/TveSdJqZPSVppJlNjqe0opHJNn5f0qBUu1IS/56bJ5Nt3EPStmZWLmknSdwfnhvNyr6CuE/fzLpKekbS40qN5CfpsPSBfepZZlQG3SJIyXAbnyrpUkkzU29d7+73xl1rIctkO9dZ/il3r4qvwsKX4b/lLpJuUegKbSvpUHefV8/PoR4ZbuMdJd2q0MU/XdLB7r4igXILXs3/A2Y2XNJRrcm+ggh96b9XMX5H0r9SXXItWgYNY/vFg+2ce2zj3GMb54/m/F0UTOgDAIDWKZRz+gAAoJUIfQAASgShD0Bm1il1lTWAIkboA5DCvb7rzMwzeN1S8yUz2y3D76S/BiT45wRKWpukCwCQFwZKWiPpq9T8+5KukjSpznJPSfosbX5tatojw3XMTPsOgJgR+gDk7v8dF93MviWpl6R/1B0V0Mw2lfRx2lvrUt9vcvTA1Bjs//0OgPjRvQ+grl9JetbdX09/08zaKzxoaXba22vrLLOwnu78l+r8PqEPJITQByDpvxfz3SFpT0k/Tnu/Z+qpf79RGEr1tUZ+5ktJe7i7ubtJOlvSqhyWDaAZ6N4HSpyZ9Zc0TiGgN0jap85R/npJjyhc7HeJuzf2SOUNGb4HIAGEPlDCzKydwjO4yxQeMzvZ3Wsdmbv7UjPbxN0XZfKTGb4HIAF07wMlzN3XKDygY2tJB0n6sr7b7CSln6s/qpGfbC/pybTvXZ16D0Ae4EgfKHHuvizV/FLS/ZLOaWTx1yStbuTzodr4yJ4L94A8QegDqLFB0gp3n9PQAma2QY2co+dx1kB+o3sfQGu05MCB4X6BhHCkDyDd8WZ2fBPLpP+/0VaSUufvM9W22VUByAqO9AHUcEl/UhhSt6HXMtW+MK+NpKU19+U39pK0Rdp3ACTA3Juzgw4AETNrI6lTJufyzaxMUleFnQT+4wESQOgDAFAi6N4HAKBEEPoAAJQIQh8AgBJB6AMAUCIIfQAASgShDwBAifj/tvUOBnLIFvAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_precision_vs_recall(precisions, recalls):\n",
    "    plt.plot(recalls, precisions, \"b-\", linewidth=2)\n",
    "    plt.xlabel(\"召回\", fontsize=16)\n",
    "    plt.ylabel(\"精度\", fontsize=16)\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_precision_vs_recall(precisions, recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通过选择阀值来实现最佳的精度/召回率权衡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 目标设定为90%的精度，阀值大概在30000左右 , 设置了阀值为30000\n",
    "y_train_pred_90 = (y_scores > 30000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8890422301959702"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5941708171924"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 获得了一个90%精度的分类器，但如果召回太低，精度再高，也不怎么有用\n",
    "* 如果工作中，需要99%的精度，你应该回应，召回率是多少？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC 曲线"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "* 本质是 真正类率tpr和假正类率fpr（错误的分为正类的负类实例比例）\n",
    "* 与召回/精度曲线非常相似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "# 真正  假正 阈值\n",
    "fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_roc_curve(fpr, tpr, label=None):\n",
    "    plt.plot(fpr, tpr, linewidth=2, label=label)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "    plt.xlabel('假正类率', fontsize=16)\n",
    "    plt.ylabel('真正类率', fontsize=16)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_roc_curve(fpr, tpr)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9607067340728046"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算曲线下面积AUC，虚线是随机分类0.5到1\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "roc_auc_score(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 召回率TPR越高，分类器的假正类FPR就越多\n",
    "* 虚线表示纯随机分类器的ROC曲线，好的分类器应该远离这条线，向左上角\n",
    "* 是使用精度/召回率 PR曲线，还是使用ROC，关键在于 正类非常少或者更关注假正类而不是假负类，选择PR，反之ROC\n",
    "* 例如：前面例子ROC曲线很不错是因为跟负类 非5 相比， 正类 数据5 数量真的很少"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练随机森林分类器，比较SGD分类器的ROC曲线和ROC AUC分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 获取训练集中每个实例的分数\n",
    "* RandomForestClassifier 没有descision_function(),但是拥有dict_proda()方法，sklearn中分类器都有这两个中的一个\n",
    "* dict_proda返回一个矩阵，每行一个实例，每列代表一个类别的概率，比如这个图片 70%是5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "# 随机森林分类器\n",
    "forest_clf = RandomForestClassifier(n_estimators=10, random_state=42)\n",
    "# 交叉验证 交叉执行predict_proba方法 预测概率\n",
    "y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3,\n",
    "                                    method=\"predict_proba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 1. ],\n",
       "       [0.7, 0.3],\n",
       "       [1. , 0. ],\n",
       "       ...,\n",
       "       [1. , 0. ],\n",
       "       [1. , 0. ],\n",
       "       [0.9, 0.1]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_probas_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制ROC曲线，需要决策值不是概率，直接使用正类的概率作为决策值：\n",
    "y_scores_forest = y_probas_forest[:, 1] \n",
    "# 真正  假正 阈值\n",
    "fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5,y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 0.3, 0. , ..., 0. , 0. , 0.1])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 继承了上边的图\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(fpr, tpr, \"b:\", linewidth=2, label=\"SGD\")\n",
    "plot_roc_curve(fpr_forest, tpr_forest, \"Random Forest\")\n",
    "plt.legend(loc=\"lower right\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9924967543226917"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rand 比SGD 好很多，ROC AUC的分数也高很多\n",
    "roc_auc_score(y_train_5, y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.986104984561094"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 再看一下 精度和召回率 也很高\n",
    "y_train_pred_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3)\n",
    "precision_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8247555801512636"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 选择合适的指标利用交叉验证来对分类器进行评估\n",
    "* 选择满足需求的精度/召回率权衡\n",
    "* 使用ROC曲线和ROC AUC分数比较多个模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1.])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 预测结果 二元分类器进行多次训练\n",
    "sgd_clf.fit(X_train, y_train)\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-594619.59270383,  167388.1440656 ,  -46865.4820205 ,\n",
       "        -150117.25373261, -106040.8836712 ,  -80438.59182758,\n",
       "        -204475.60066699, -234926.14649485, -171094.54274397,\n",
       "        -206504.1488826 ]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 内部实际上训练了10个二元分类器，获得图片的决策分数，然后选择了分数最高的类别\n",
    "# 返回10个分数，每个类别1个\n",
    "some_digit_scores = sgd_clf.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 拿到分数最高的索引\n",
    "np.argmax(some_digit_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 目标类别列表会存储在classes_这个属性中，按值大小排列，分类标签\n",
    "sgd_clf.classes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 通过索引 来拿到分类标签中对应的值\n",
    "sgd_clf.classes_[np.argmax(some_digit_scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用OvO策略，一对一或者一对多\n",
    "from sklearn.multiclass import OneVsOneClassifier\n",
    "# 把二元分类器，封装成 ovo\n",
    "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5, tol=-np.infty, random_state=42))\n",
    "# 训练\n",
    "ovo_clf.fit(X_train, y_train)\n",
    "ovo_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 多个ovo\n",
    "len(ovo_clf.estimators_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用随机森林 训练 \n",
    "forest_clf.fit(X_train, y_train)\n",
    "forest_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 0., 0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机森林直接将实例分为多个类别，调用predict_proba()可以获得分类器将每个实例分类为每个类别的概率列表\n",
    "forest_clf.predict_proba([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 评估分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.85462907, 0.82044102, 0.85772866])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用交叉验证评估SGD的准确率\n",
    "cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.90796841, 0.90874544, 0.90988648])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将输入进行简单缩放 ，可以得到准确率 90 %以上\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "# 实例化\n",
    "scaler = StandardScaler()\n",
    "# 数据缩放\n",
    "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n",
    "# 再次评估\n",
    "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 错误分析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 项目流程\n",
    "1. 探索数据准备的选项\n",
    "2. 尝试多个模型\n",
    "3. 选择最佳模型并用GridSearchCV对参数进行微调\n",
    "4. 尽可能自动化\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 确定了一个相对合适的模型，进一步优化，分析其错误类型\n",
    "* 查看混淆矩阵\n",
    "* 使用cross_val_predict()进行预测\n",
    "* 调用confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files (x86)\\microsoft visual studio\\shared\\python3.7.4\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5726,    3,   26,    9,    9,   52,   49,    9,   38,    2],\n",
       "       [   1, 6468,   44,   20,    7,   42,    7,   10,  133,   10],\n",
       "       [  55,   40, 5332,  100,   80,   26,   89,   54,  167,   15],\n",
       "       [  56,   46,  136, 5314,    1,  239,   39,   61,  147,   92],\n",
       "       [  23,   30,   30,    9, 5350,    9,   55,   25,   88,  223],\n",
       "       [  68,   36,   37,  176,   69, 4632,  113,   30,  174,   86],\n",
       "       [  29,   28,   53,    1,   36,   88, 5627,    7,   49,    0],\n",
       "       [  21,   25,   66,   25,   55,   12,    6, 5799,   16,  240],\n",
       "       [  49,  150,   74,  147,   14,  167,   59,   24, 5018,  149],\n",
       "       [  45,   36,   25,   79,  158,   30,    2,  222,   86, 5266]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 预测标签\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)\n",
    "# 实际标签和预测标签，进行混淆\n",
    "conf_mx = confusion_matrix(y_train, y_train_pred)\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib的matshow 函数来查看混淆矩阵的图像表示\n",
    "plt.matshow(conf_mx, cmap = plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 看起来不错，大多数图片都在主对角线上，说明它们被正确分类\n",
    "* 数字5 看起来比较暗，说明1. 数字5图片较少  2. 分类器在数字5上执行效果不如其他数字上好\n",
    "* 假设把焦点放在错误上，为取得错误率，而不是错误绝对值，需要将混淆矩阵中每个值除以相应类别中的图片数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "row_sums = conf_mx.sum(axis=1, keepdims=True)\n",
    "norm_conf_mx = conf_mx / row_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 用0填充对角线 只保留错误，重新绘制\n",
    "np.fill_diagonal(norm_conf_mx, 0)\n",
    "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "* 每行代表实际类别，每列代表预测类别\n",
    "* 8，9列比较亮，说明许多图片被错误的分类为数字8，9\n",
    "* 类别8，9行也偏亮，说明数字8和9经常会跟其他数字混淆\n",
    "* 有些很暗，比如行1，大多数数字1都被正确的分类，一些和8混淆\n",
    "* 5和3是错误最多的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 结论\n",
    "* 改进数字8和9的分类\n",
    "* 修正数字3和5的混淆\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何优化分类器\n",
    "* 尝试多收集这些数字的训练集\n",
    "* 开发一些新特征来改进分类器\n",
    "* 优化分类器算法\n",
    "* 使用pillow或opencv对图片预处理，让显示模型更突出\n",
    "* 分析单个错误"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAccAAAHBCAYAAAAcpXCvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydd3hbd7n4P5Ity5KX5L33thMnju3YaZqdLlKSki5aWmhLGYXCvXAvP+ChD+V57r29rMJltJQSoE0hpGnTZjU7zvBKneEVRx7ylPeSJVm25vn9EXSIk7RNE8kOVJ/n0R+WjnVeSed83++7JYIg4MWLFy9evHj5B9L5FsCLFy9evHi51fAqRy9evHjx4uUKvMrRixcvXrx4uQKvcvTixYsXL16uwKscvXjx4sWLlyvwKkcvXrx48eLlCnw/4nVvnYcXL1cjmW8BbhDv/ezFy9Vc8372Wo5evHjx4sXLFXiVoxcvXrx48XIFXuXoxYsXL168XIFXOXrx4sWLFy9X8FEJOR5leHiY4eFhxsfHGRoaoqysjKioKGQy2XyK5cWLFy9ePuHMuXIUBAGn04ndbqe+vp6TJ09SU1PD8ePH+dvf/sbatWtRqVRzLda8IwgCNpvtuo/38fFBIpEgld5axr8gCOLjWn8D+Pr6elRuh8OB0+nkg5rqS6VS8eHl2lz+/V3rN7z82pNKpUgk/6wJvJdwOBw3/TkEQcBut1/1PcE/rrl/xu/pWvf05Vz+uebi810uz5XXpTu/5zlXjtXV1dTU1HDgwAFaWlowGAw4HA5ycnKw2WxMTk5+4pRjf38/jY2NPPHEEzidzmv+sK7nXa899dRTFBUVsWjRIhITE+dtoXc4HFitViwWCwA6nY6enh7OnTsHwNDQEHV1dWi1WhwOByEhITz33HOsWbOGuLg4t8pis9nQ6/W8+OKLvP/++/T09GA0GsXXBUFAIpGwbt061q1bxxe+8AW3nv9fAYfDwcDAAEePHqWzsxO9Xo9Wq0Wn0zEwMABc+h5DQ0O56667SElJISsri9LSUoKDg/8pF/+uri7eeustCgsLSUtLIykp6WP9v91uZ3x8HI1Gw7e//W2GhoawWCxIpVKioqKIjY2lpKSE+++/n4iICHx9fQkLC/PQp3EvWq2Wvr4+DAYDjY2NjIyMYDKZxNf9/PxYtGgRaWlpxMfHk5GR4RE5nE4nNpsNk8lEW1sb3d3dtLa20tnZSV9fHyMjIwiCwMMPP0xpaSkrV6686XPOiXLs6+sTFUB1dTXt7e1oNBomJiaw2WwEBgayePFiEhMT50wx2u120cIAMJlMTE5OotVqZ7l65XI5S5cupbCwkMjISLfL4XA46OjooKKigpGRERwOx1ULjGt3dLlyPHz4MFqtlsbGRr761a8SEhLicXe0IAjo9XoEQWB6epru7m66u7sZHBykt7cXgMnJSfR6Pf39/QCYzWb6+/sZHx8XL3B3LqBOp5OZmRna2trQaDTU19dz9OhRTCYT/v7+pKenExMTA4DRaKSyshKdTsfFixfdJsO/Cg6HA71ez86dOzlx4gQjIyP4+/ujUqmIj48nJCQEuHQdyOVyJicnOXbsGGfPnqW2tpavf/3rBAUF4ePjM2+fwW63U1FRwdDQEGNjY+h0OjZu3EhqaioRERH09PQQEhKCj48P27dvZ2BggL6+Ppqamjhz5gwbN2782Mqxp6eHuro63nrrLdrb2zGZTNjtdiQSCWazmbGxMSYmJujr6yMsLIzIyEgeeeQR1Go1crncQ9/Ex8NsNqPVajl27BgTExPY7XYAxsbGmJycZGZmhsHBQaanp5mZmRH/z9fXl9bWVuLj4yksLHS7cnQ6nWi1Wurr6+ns7GRgYACr1cr09DRmsxmZTIZCoSAwMJCGhgY6OztJTU11y7k9qhwFQWBiYoKmpibOnz/P3r17aWpqwmg04nQ6kUqlOJ1OfH19ycjIIDY2VrwBPSGLy51rNpsxGAxYLBbR4hkdHWVgYICKigra2tro6emhtbWVgIAAnnrqKfGidjeui7Kmpka0Dq+0Al0K/PLXzp07R0tLC42Njdx9992kpaWhVqvdLp8Lu93O9PQ0Fy5cQBAEJicnOXPmDHV1dbS2tqLRaEQZfXx88PHxwWq1ii4PiUSCv78/QUFBqFQqtyhyu92OyWSiv7+fU6dOcerUKU6ePIlEIiE1NZWUlBRuu+028vLyEASB4eFhOjo6MBqNdHZ2itegl0vf5cTEBF1dXRw6dIjW1lbsdjtpaWnk5OSgUCiuOn5sbIyqqir0ej0nT57kscceQ6FQzJtydDgcTE1NsX//fjQaDV1dXTQ0NBAdHY1EIsHhcHD27FliYmKQyWRs2bKF5uZmJicnxfdITEzks5/97Mc6r1arpaKigu3btyOXy8Wwgev6dF2jp0+fRqVSkZyczMKFC8nOzr4lciycTid6vZ6KigpeeeUVBgYGROXuegiCIIZyLv8/m81GU1MTUVFRzMzM8PWvf91tclksFiYnJ6mtreXw4cM0NTUxMDBAXFwcwcHBBAcHk5SURFhYGEqlksrKSgwGA2az2S3n96hyNJvN/Od//icnT55Eq9Ve5RsOCQlhenoau92OTqebtSNxJ4IgMDU1JbqI3nrrLc6cOUNfX5/oKnJxZazKbDZTXV2NXC6nqKjI7W6jCxcuUFlZyfHjx0Xr8HqZmpqira2NF198kc997nPcc889bpXtcnp6eqitreWLX/wiFotF3GzA7BhEUFAQwcHBREVF0draKro1AwICyMnJYenSpdx+++0EBgbetEydnZ1UVlbys5/9DK1Wi1KpJCkpiZ/+9Kfk5+cTEREh3txOp5OpqSleffVVuru76e3txWw2z+tifqsgCAJarZZt27Zx8OBBMjMz+fa3v01eXh7Lli275jVpt9uZnJxEoVBw6tQpzpw5c1W8ba4ZHBzk/Pnz/OpXv5q1ljQ1NaHRaLh48SLV1dVYrVbg6tjZjVJTU8OZM2eQSqUsX74ck8nE0NAQXV1dVx2r1+tpbGzk0Ucf5ZlnnmHjxo0sWrTILXLcKGNjY5w5c4bvf//7qNVqUlNTiYqKIiAggIiICIKCgrBaraSlpREQECD+X19fH62trbzxxhuEhIS43bCprq7mrbfe4u2332blypV89rOfZe3ataSnp4ubNYlEwt69e9m/fz8qlYrMzMyPbfl/EB5Vjk6nk6GhIaampsQL8e677yY7O5vc3FzMZjO7du3izJkzom87KirK7RaQyWTiN7/5DXV1dfT09DA4OIher2dmZgaHw/GB/+daFKanp2ftLt2JyyUQFBSEXq+/4fdxKSpPYTKZGBwcxGq1YrfbkcvlxMTEEBISQnBwMKGhoSxZsoTw8HCkUilnz55Fp9OJyjE1NZV7772Xz3zmMwQEBNyUxWa1WmlsbGTLli00NjZit9t56qmnyM7OJi8vj4ULFxIUFDTrHHq9npaWFjQajXgT+fv7f+IVI1xSEm1tbahUKu68807uu+8+QkNDr/oOXXR3d9PW1sbOnTuprKxEqVTy+c9/ntDQ0Dm3gqampujo6GDPnj1cvHgRjUYjeoNcHDhwAIlEgtFovOo1d1BUVMTo6Cg1NTU8/vjjhIWF4XA4mJiYAGBiYoL333+fffv2MTk5idPpxGAw8NZbb6HT6Xj11VfdLtPHITg4mMWLF/Pb3/6WwcFBIiMjyc7OxsfHB5lMhkwmw+l0olQq8fX1xel0Ultby7lz56ivrwcgMzOT3Nxct8pltVpxOp38+Mc/JiMjg+joaMLDw1EoFAiCgNls5uWXX6aiooKenh42b97MunXr3CaHR5WjVColMTERi8VCVFQUAKtXr6agoICcnBzq6uoICQnB6XQyNjY2yw3nTmw2G/X19VRWVoqxsI+DUqn0WCxUpVKRmprKokWLOHHixMf+f4lEQnR0NMHBwR6Q7tq4EgpWrVpFeHg4wcHBhIeHU1xcjM1mY3h4WNwQyWQyAgMDyc/Pp6Cg4KYv3PHxcfr7+zl8+DANDQ2YTCaKiopYv3492dnZpKamXrVAC4JAf38/lZWV6PV6srKyyMvLw9d3XiuZbhkkEgkKhYLU1FT8/PwoKCi45nGumHNdXR2nT5+moqICmUxGVlYW69evR6lUzulmY2pqip6eHg4dOsSBAwfo6Oigr6/vquNc8XCAkJAQFAoFMpls1vMA+fn5N5QklpaWRnFxMa2trZSUlBAZGYmvr69ovU5MTKBSqdDpdLS3t9Pf34/FYqG9vf0qd/V84OfnR1RUFOvXr6enp0e0Hq/E5X0ZHh6mra0NrVbL4OAg8fHx4pruTlQqFVlZWaxdu5awsDD8/f1FOcbHx2lvb+fYsWOMjY0REhLC6tWryczMJDQ01D0CXCst9rLHTeFwOASNRiOcOnVKOHDggHDgwAFhbGxMsNvtgtVqFX7wgx8IhYWFgp+fn5CTkyNUV1ff7CmvydjYmHD//fcLMTExgkQimfWQSqXi48rXXI9HH31U2L17t0dkEwRB6O3tFXbv3i3I5XLB19dXkMlksx6+vr6irL6+vrMe/v7+wp49ewSdTucx+QRBEDo6OoQ333xTUCgUgkqlEu644w5hfHxcsNvts47btWuX8KUvfUn8PiMiIoSVK1cK77zzjtDR0XFTMtjtduHw4cPCt771LUEikQhlZWXCD37wA2F8fFxwOBwf+H8Wi0XYunWrEB0dLahUKuG5554TLl68eDOifNR9c6s+bgqr1SocOXJEuPfeewWVSiVER0cLr776qtDY2Hizb31DNDQ0CL/4xS8ELjVU/8iHVCoVli9fLjzxxBPCN77xjVmvSSQSYdu2bYJWq/WYvLt37xaeeOKJWWvLwoULPXY+d2MymYQzZ84IP/jBDwSVSiVIpVIhKChI+NrXviY0NDS4/XwOh0Ow2WxXPW82m4XDhw8Ljz76qBAXFyc88cQTwptvvnkzp7rm/eJxyzE1NZWkpCTRInRlZ1ksFk6cOEFvby9yuZxFixa5JQ51LQICAnjyyScZGRkRM7FWrFhBVlYWWVlZpKamYjQa6ejo4MUXXxSzzVzyqtVq0fL1BDExMQQFBbF161YCAgIIDg4mNjaW8fFxdDodjY2N/Nd//ddVlrVarSYnJ4clS5Z4JFnochISEggPD+fo0aNIJBICAwMJCQkR3W4Oh4NDhw7x5ptvcvToUQRBYMmSJaxatYqvfOUrREdH31RmniAItLa2smvXLt566y1WrFjB9773PYqLi2fJcS1+8pOfUF5ejtFo5Nlnn+Wuu+4iLS3thmX5pNHW1kZ9fT1VVVXs3buXhIQEnnjiCb7xjW8QGhoq7ujniqmpKf70pz/x1ltv0djY+JHHP/jgg+Tl5ZGZmUlZWRm/+tWv2LJli/j6ggUL+O53v8v69es9lhAIUFtbS1tbm/h3SUkJq1at8tj53IHBYGBkZISqqip27NhBW1ubGCrbuHEjDzzwACtWrPBIacrltchOp5PJyUnq6up4/fXXGRkZQSaT8cc//pH09HSPrM8e9yu5fNYurFYrAwMDNDQ00Nvby8zMDAEBAWRlZc0K9roTX19fcnNzue+++8jPz8dut1NUVERsbCxRUVFMT0/T19dHb28vNptNVEAymYy77rpLPNZT+Pj4EBgYSHFxMXK5HLlcTkBAAPX19Vy4cIHGxsZrJuuEhYWxZMkSAgMDPe7O8vX1JTAwkNzcXDEj1XXhGgwG+vv72blzJ/X19UxNTZGcnMw999zDbbfdRmJi4k3HooS/J41MTk4SEhLC/fffT05Ozoe6UEwmE3V1ddTU1DA2NkZOTg6rV68mOTl53jME/xkwmUx0dHSwa9cuLl68KKbJL1u2jMLCQpKTk+dFrpmZGd577z2am5sZHx+/5jEpKSmkpKRQUFBAaWkpoaGh+Pj4sHv3bs6fPy/mEGRnZ1NaWsrSpUsJCQlxu6t9dHSU4eFhNBoNp0+fpre3V9xcLl68mOXLl7v1fDeL2WzGbDZjNBppaGgQkxYvXLjA+fPnMZlMhISEsGnTJlatWkVJSQlRUVEeW38EQWBsbIyLFy/S0dFBXV0dgYGBxMfHk5KSwsKFC1GpVB7ZoHlcOTocjlldDIxGI83Nzbz55psMDAzg6+uLSqUiNzfXY8rRx8eHpKQkPv/5zzMzM4PT6SQiIgJBEDCZTBw7dozKykpOnz7N1NQUcCkO4+fnx6OPPkpRURHx8fEeke1yGV2LjcViYWRkhLfffpszZ87Q1tYmKsfLLaSwsDCKi4vnbKGXSCRX7aytViv9/f1UVVXxt7/9DbvdjkqloqSkhAceeICcnBy33DiCIIjxpNTUVB555JEPjbO6NmE7d+6koaFBjJHefvvtt0Sc51bH4XAwMjLC4cOHeemllxgdHUUmk/Hcc89x++23k56ejtlsxtfXVyzdmSssFgvl5eWzMlKlUqlYQuHv78+yZctYs2YNjz/+OHa7nYGBAc6dO8cPfvADDAYDAP7+/ixfvpx169a5zZNgtVpxOBziQ6PR0NjYyI4dO6itrcVsNuPn50dCQgJlZWWsWLHCLee9Uex2O3a7HafTKTaAGB4eRqfT8dprr9Ha2ipaigDh4eGkpKTwrW99i6SkJIKCgjwilyAIOBwOpqen0Wg07N27l/Pnz9Pf389//Md/UFRURH5+vkfO7cKjytHhcHDx4kWGhobErEWj0ShmblmtVnJycli+fDmrVq3yeAMAlUolKmqj0ciePXt45ZVXqK+vx2KxiK5UuGQp+fv7s2LFCiIiIjwq1+WYzWaampr44Q9/SE1NjXhR3oo4HA6qq6t59913efnll7Fardxxxx3ccccdfP3rX0cmk7mt9EUqlXLHHXfQ3d1NR0cHY2NjKBSKD9zp7927l0OHDvHaa69RVFTExo0b+eY3v+m1GK+TpqYmjhw5wve//32x9MFut/P8888TFhZGXFwcxcXFrFq1itzcXI8vVJfj5+dHWVkZ9fX1ouXo6m6Tl5fHN7/5Tfz9/Zmenqa6uprz589TXV3Nzp07xc8SEhLCM888w+OPP+62wnVBEHjnnXeor69Ho9HQ3NzMxMSEWDhvt9uJiIggMzOT1157jejoaJRKpVvOfSPYbDaqqqrEAntXUxG9Xs/09LToRbs8lDM5OUl9fT3nz5/Hz8/PY8pRr9dz7tw5ysvLeemll1i8eDHLli3j2WefdVud9EfhEeXoavFz7tw53nvvPYxG46wbbHR0lKmpKeRyOWVlZdx///0EBwd7PHtwenqaoaEhqqurOXbsGBqNBo1GM6vUxIXT6cRqtXLgwAFKSkpIS0ubkx/EYrEwNjZGfX0909PT81o39mG4ioa3bt1KQ0MDgiCwadMm7r77bkpLS/Hz83Pr+SQSCZGRkTz44IOsWLGC6Ojoq87hcDgwmUzs3LmT9957j7q6OjF1v6WlhZdeegmA6OhowsLC8PPzIycnZ85utn8mYmNjWb16Nb/85S/F5+x2O2fOnMFoNGI2mzl//jwajYbo6GiysrLEdnKejn8rFAruu+8+0dpbsWIF4eHhBAUFERAQQHl5OX19feh0Os6ePcvo6Cijo6PiGuRCJpOJlu/N4lpb3nzzTTo6OhgdHUWv12Oz2UQrUhAEDAYD7e3t/L//9/+Ii4tDrVYjk8lYsWKFGNdXKpUeb8M3OjpKe3s7P/3pTxkeHsZoNDI9PU1gYCBqtVrM0I+IiBC7b509e5bu7m76+vpoaGggMTGRzMxMt8ql1+tpamrivffeQ6PR0N7eLnZkcjgc1NTUiIX/ERERHu0w5BFt1Nvby5kzZ9i/fz/vvffeB5ZouG6qRYsWefRDuizF9vZ2Wlpa2L9/P7t37xbdK9fCpRyPHj2KUqkUfwxP4+rgMzIy4vFz3QxTU1OcO3eOkydPMj4+TmBgIGvWrKG0tJSsrCyPnDMgIOADC6YFQWB0dJS2tjb27NlDbW0tOp0OuBSj6ujoEOM9CQkJREZG4uPjg8lkIj4+nqioKCIiIrwdc/6OWq0mKCholrvRZrMRFRXFwMAAg4OD1NXV0dXVxfDwMH19fSgUCkwmEzk5OR6N0fv5+XHbbbcRGRmJUqnk3nvvBS55XYaGhtiyZQvt7e309PR8YJtA15rwYXXOHwdXU4SGhgaxoYlLwfn4+BAQEMDU1BQzMzMMDQ3x9ttvz9qkORwOMjIyiI+PJyYmBrVa7VGDYWZmhvHxcZqbm3E4HPj4+BAWFkZubi6hoaGEhIQQHh5OXFycKCNc2oC6+ple3rfYHYyMjIgt7Pbs2cPo6CgzMzOoVCrkcjkmk0nsmRwTE0NiYqJYxqZUKt2+wfXIN//Xv/6VI0eOUFNT84HHSKVSFi1aRGxsrNutjCuxWCycPHmSn/3sZ5w+ffq6CoEFQcBisbB161ZsNhtyuVy8Cb38Q+FYLBbUajW5ubk88MAD81IIDpd+44MHD/LSSy/x/vvvz0pg6u7uRqlUirHG9vZ2pqen6e/vR6VSkZ2dzWc+8xm+8pWveCxj+p8NX19fMbRwOQ8++CBwafPoite3trZy8eJFXnjhBXJyclixYgUvvPCCx6wfmUxGYWEhhYWFs55vampi586d/P73v//ICTdWq5Vz58596Ab548rkWsQvb7MmkUhQKpVkZWXR1NQ0S2kODQ0xODgIwPnz5wkICCA8PJzFixezadMm7rzzTo9lyYeGhpKXl8fXvvY1sW55+fLlxMXFfeD9OzAwwPj4OKdOnfKITNu3b+fQoUPs2bMHgKSkJPLz80XXbUdHBwMDA7S0tCCRSAgPD2fjxo2sXbuWoqIisYeyu5i3Kmin00l1dTVFRUUUFBS43Ty/nKmpKX7/+9/T0tJylWvFx8eH+Ph4AgICxItCr9djMBjEDhdziVqtpqioiB//+Mds3bpVbNit0+mu8v/fSi7X+ZZl586d7N+/X+z9mp+fT35+Pp/61KdISEggMDBQVI42m42pqSmam5s5deoUnZ2dvPLKK6LVO5cx5n9WpFIpgYGBrF69mrKyMqampsjPz+f999/nxIkTfOc73+HJJ58kPT193l3WmzZtIjs7m7S0NBYuXMhLL73E9u3b3XoOV8eoF154AaPROEs5BwYGkpWVRXNzM9PT0+LzdXV1YlefoaEhsbn38ePH6e3t5cSJE/z3f/83oaGhbjcg/P39iYmJ4bHHHhOzzwMDA69pqQp/HzRw/Phx3n//fSQSCcnJyW7PEVm2bBnJyck8/PDDYqs612bDJYfNZsNgMKDT6WhububYsWPU1dURFhbGV77yFYqKitzWYc0jylGtVot+atdFIpPJUKvVJCYmYjQaaWtrY3JyUuxY70mkUikqlQqVSiVmuC1atAiFQoFUKiUjI4OgoCDxAmxsbKS1tXVelKOvry/h4eGsXLmSwcFB2tvb6e7upr+//6oWcSaTifb2dre5hj4OPj4+qFQqsRPIyMgILS0tonKZS/ekIAjiFAar1UpZWRllZWUUFBSwfPlysbuGa5F2OBxYLBbCwsLETL3a2lo6OjqIjIz0KsfrxNUf2dXlasWKFfj5+dHQ0EB9fT319fXiUIG5QKlUEhMTw4IFC7Db7SgUCjIzM1m1ahVJSUnEx8d7rCbOld2+ePFibDbbrHvVpTiDg4NnKc3IyEgyMjLIyckRR71duHCByclJ2tvbxVrwlStXEh0d7VZ5pVIpfn5+HxkfdjgcGI1GampqRNkSEhLIzc11+/cYHx8v1kvGxcV9oEvZZrOJx87MzNDQ0EB/fz9HjhwhLi4OpVLpljCdR5RjamoqcXFxBAUFYTQaxbqevLw8Nm7cKM7jmpmZwWw2e1wJ+fv7c++992Kz2Whvb8dut/Nv//ZvYtwpLS1tlnLctm0b+/fvF/sGzjUBAQEsWbIEhUJBVVUVe/bsEYudL1c6Y2NjVFdXf6whye7C39+f5ORkFAoFExMTaLVaDhw4IFoUnirL+SCEv08NUKvVfPWrX+W2224jKSnpmskWPj4+oqtLIpEwPT3N3/72N1pbW0lNTfWoF+NfFalUSnFxMRkZGbS1tfHlL3+Z8vJyLBYLqampN5z0crm35KM2XKGhoSxcuJD7778fh8NBVFQUTz/99KxjXJuh63m/G+HDSr4SExNn/Z2WlobT6cRoNNLb28vx48d58cUX6e/vx2Aw0NbWxh/+8AeSk5PdrhyvF7PZTE9PDy+//DIXLlzA399fbF7g7sSr630/mUxGbGwssbGxLF68mO3bt7Nv3z62bdtGaWkp4eHhbpHNI8rxU5/6FDk5Odx1110cOXKEvLw8MjIyyM/PRyaTceDAAfbs2SMmTHgahULBxo0bWbFihdhsPDY2VtyZXDmK5VbhwIEDHDlyhPLycnGEzOUkJiby0EMPzXmHErh0IX/xi1/EZrNx5MgRDh8+zC9/+UtaWlq48847+dKXvjRnskgkEp555hmefvpp7HY7AQEBYs3bR9HZ2Ul3d7fHG7d/UggJCSElJYV77rmHd999F41Gg1qtZv369TdUX9rU1MTk5KSofD/MRRsTE0NkZCRlZWUIgnDV7+9wOHj55Zepra1FLpdTWlo674PVpVIpwcHB5OTkkJGRwUMPPcSnP/1pWlpaMBqNtLS00N3dLc6jnAvsdjtWqxWDwcCOHTs4dOgQlZWV5OXlsW7dOr797W+jVCpvieS1oKAg7r77biIjI9m3bx/79+/H4XBw//333/R7e0Q5ujS7XC4nIiKC8PBwQkNDCQsLE4tKXWOPHA7HnFg+fn5+hIaGiinVcrn8AxXi0NAQo6OjHpfpWrh2am+99RbHjh2js7PzqjipC5drZD6QSqUEBASwdOlSLBYLo6OjNDU1UVdXB1xqMJ+QkDBnitvf3/+GztXV1UVPTw9w6RrxNiO/OVxeorvuuouuri7Gxsaoqalh5cqVN6Qcd+zYIc4KjY2NJTMzk6ysLJKSkoiJiZnloZBIJGIi0ZWYTCZ0Oh179uyhtbUVwK11uDfD5TNQw8LCeOyxx3j77bcpLy9Hr9fT3t5OSkqKR5SjSxFOT08zMjLCwMAAOp2Ozs5OzGYzra2tmEwmHnzwQUpLS8nLy7ulktYkEgmhoaGkpKSQnv3Ec7AAACAASURBVJ4uzvR0Bze8ErhcolarlYiIiKvcJkFBQQQFBYldXwRBwG63c/HiRdrb25mZmcHX1xeZTDZnC/yVreyuRBAErFYrvb29YimFK5YwVzKOj4/T2NjI73//e0ZHR2c1JpgvHA7HNYcwSyQScnNzmZmZEeument7cTqdtLW1ER4ePi9W7fXgyrZ0TUkIDAwkNDR0Xouy/1Xw9/entLSUqqoq6urqqKurY2ZmhuDg4I+tjMrLy6moqBD/ds0DLSsrIyAg4Lrc90ajke7ubs6ePUtNTQ3T09Pi6KNbbWSZVCplw4YNNDc3U15ejslkYnh4+KY36w6HA6vVitFoFNcU4e9jn0wmE5OTk3R2dqLRaGhpaaGurg6HwyF2xNm8eTPFxcXzbmlfC6VSKcopk8nctmbekHIUBIHTp09z8OBBNBoNv/vd78Ri1g/CYrHQ1dXF//7v/3LhwgWsVivR0dEsWLCAkpKSG/4A7mR6epqmpiZOnTpFU1MTcEnJx8bGkpKSMicyVFRUcOjQoauGMM8nY2Nj+Pv7ExAQcNViEh4ezpo1aygsLOTEiRN0dXVhNps5d+4cCxYscPtsTndhNBrZvn07e/fuRa/Xs2bNGjZv3uzxAvZPCr6+viQlJaHVajl69Kg4tulmEyVOnz5NXV0dtbW1REdHX1f6/vbt29m/fz87d+4EEHtyuvqp3mokJibOao2YlJR0031sR0dHaWho4I033qC3t1eMvY6NjYkj5q6sRw8ODuaBBx7gM5/5zC3XA/ZKJBIJ/v7+bnX13pBylEgkFBQUiGUGv//977n77rtJT0+/5sV28eJFGhsbefvtt+nu7sZmsyGTyXjqqacoLS31WAuij4PZbEar1fLCCy+IrkwfHx/KyspYuHAhCQkJHj2/1WrlxIkT7Nixg+rq6qsyUC8fpQKXhouWlJSwbt06j1i1NpuN3t5ejh07RkdHB8uWLWP9+vVXKUfXxIZjx47R1dWF0+kkKiqKZcuWzemMyY9DbW0tVVVVvPrqq0xPT1NUVMSzzz6LWq2+5SyJf2ZMJpPYfepGS33S09PR6XR0dXWJz1ksFurr6/nFL37BwYMHSUtLY9OmTbOut6qqKhobG2lpaeH48eOz8hvuvfdennrqKRISEuZk7ZmZmaG3t5fu7m7UajXJyclIJBKxVOFynE4nW7Zs4cyZM2KCWWho6A3fS1arlYsXL7Jjxw6am5sZGBhg9erVTExM0NHRIbbOdDgc+Pn5ERwcTFxcHDk5OSxbtoySkhKPNfW4Us6BgQGkUunHXmsNBgPd3d1UVlayefNmt214btitqlKpSEpKYmBggN27d6NSqTCbzeLAS4lEgsPhoLe3l9OnT3P+/HmqqqowmUwEBweTmJjI7bffTlJS0rzFeVyuBpPJREtLC2fPnuX06dMYjUYx+7G4uJiUlBSPN6t2OBz09PTQ1dUlFgZfC4lEgkwmE/tZeiqLraenh7q6Og4dOkRoaChWq1V0ibnqnrq7u6mqquLs2bOcPHkSm81GRkYGhYWFpKam3hIuVVczAJdbX6vVUlVVRXl5OT09PSxfvpzly5dTUFAwb/HbfyVc9cFdXV1cuHCB0dFRIiMjkcvlN7SrLy0txeFw4OvrS0dHh5g4pdfrxS5IKSkp4sLuoqamhqamJtrb22lraxNLuAoLCykuLmbhwoXu+cDXgcPhwGAwcPLkSfz8/EQr0NWpKTQ0lMDAQKxWK6Ojo5SXl9Pd3Y1UKiUsLAy1Wn3D2d9Wq5Wuri7OnDlDT08P0dHRREVFMTMzw8zMjLh5kcvlREVFUVpaSlpaGtnZ2RQWFhIfH+9x69pisXDu3DmxG871KkdXaKSpqYn3338fq9VKbGys29bEm9JK8fHxZGdn873vfY+hoSEWLVrEgw8+KO6+Z2Zm+POf/8yZM2fEqdsSiYT8/HweeeQRVq5cOWcLqGvnevkO1mQyMTo6ysWLF/njH//I8ePH0ev1wCW3kEKh4N57752TOi3XvDJXK6crX4N/KMaQkBDuuusuysrKPCKLIAgcOXKEgwcPsmfPHn73u9+Rk5MjKg+bzYZOp+PVV19l3759Ytf+qKgoNm/ezObNm+dtnNHlOJ1O7HY7Pj4+2O12DAYDW7Zs4fDhw2g0GpKTk3n22WcpLS29Zd2//0y4Zm5WVVXx8ssvMzQ0hFqtZuXKlTfcv/bLX/4yK1euZNu2bfzf//0fBoNBvIe7u7vp7u6mpqaGbdu2feR7yeVyfvjDH7J48eKPLcfNIpFI2LZtG1qtVnxu+fLlFBUVcfvtt5OVlcXY2BinTp2ivLyciYkJcVJPTEzMDcX6XFMt2tvb6erqwuFwiBm/er1eTESTSCQEBQWxZMkSfvrTn15VcuJpJicn+fGPf8yyZcuu+7dxGTZtbW1s3bqVgwcPkp+fz8qVK932+0o+wt3xoS86nU4MBgPvvPOO2IHmyhvA1S1CJpORmZnJmjVrWLp0KevXr0etVs9Jtphr/ltNTc0sq2x8fJy+vj4GBwfFxruCIBAREUFaWhorV67ku9/9LkFBQR5PWx4eHmbhwoVMTk5eFVB2Op0IgoBSqSQlJYXnn3+e2267jbCwMLd3H5mcnGTr1q3iSDG1Ws3rr78u1gyWl5ezb98+zp07R1NTEzKZjLS0NEpLS9m8eTNpaWlERkbOa9anaxqMTqdjdHSU+Ph4Ghsb2b59OxcuXCAhIYH8/Hy+/e1vk56efiO/7/ynON4Y1+3bHBsbQxAEwsPDP/JYV53rX//6V+rr6+nt7UWpVFJYWEhJSQkPPvggKpXqhu8hu93O1NQURqORyspKjhw5wh/+8Ifr/v/8/HyWLFnChg0buPPOO1EqlXPqPnd1dvnLX/5CRUUFlZWVaLVaZDIZcrkcPz8/ZDKZ2JzC1Z/W5e531WF/XA4ePMiBAwd47bXXMJlMAGISks1mw2q1EhgYyNKlS1m6dClPPvkk0dHRc97RqK+vj3Xr1vHggw+yfPly1q9ff83jXIMFent7aWho4MiRIxw9epTQ0FBycnL40Y9+RFxcHAqF4uPqlWsefFMrmKvgu7S0lK6uLhQKBcePHxd3dq7uGH5+foSFhXHPPfdQUFBAUlISISEhc6IYbTYb4+PjHDx4kIaGhlnDUc1mMwaDQWyg62qhVFJSQmFhIWvWrJmzeh6n0yl28b/yfFKpFIVCQVFREaWlpRQWFn5kAtSN4uopOzExgcFgQK1WixmHIyMj1NbW0tjYyMjICGq1mvT0dJYsWcK6devIyckhKChoXhWjxWJhx44dNDY2MjQ0JFrbvb29aLVaFixYQFlZGcXFxaSnpxMYGHhL1GvdashkMoxGI/X19RiNRgICAsRm5HDpvhoaGhJLYS5evEhDQwNSqZT09HSKiopYtGgR6enpHzqQ+nrw9fUVO/EUFxcTFBREREQEzc3NdHR0iA0yLketVhMVFcWSJUsoLCwkIyODBQsWEBAQMOe/tyvj3ZUAFBUVxcsvv4zZbBaHLruOA0hOTqa0tJS1a9feVEhnaGiIlpYWscmKv78/wcHBBAUFERwcjEqlIjk5maKiInJzc+dFMcKl3zc+Ph6NRoNEIhG73EilUgRBYGZmhv7+foaGhujs7GRkZAS9Xo9er+e2224jOzub3NxcEhIS8PPzc5teuelVzNfXl5ycHDZu3IhKpUKj0YhuQD8/P1asWIFSqSQuLo4nnniCkJCQOd21ucoMjhw5wtDQEGaz+apjJBIJcrmcgIAAEhISWLt2LaWlpZSWls6ZnBKJBIVCgSAIszp4uHaXERERrF+/XhwL5ClcSQB+fn7iMOiDBw/S39+PRqNBp9Ph5+cnNkheunQpJSUlrF692mMyfRxmZmbYsmULFy5cwGg0Eh0dzcTEhOg6uueee1i/fj0FBQXemsYPQaFQMDk5yYULF+jp6UGtVhMXFycquqmpKZqamqiurkar1dLZ2UlkZCSFhYUsWbKEu+++m6SkJLd3SkpNTSU1NZV77rmHd955h/LycoaGhq46Li0tjQULFvD5z3+ehQsX3hK1ebm5ucTHx5OZmcnevXvFcITZbMbHx0cM5RQVFbFq1SrWrFlzU/E+i8UixvF8fX1Rq9VkZmaKkz/i4uLIy8sjKyvrpjcwN4Or7V5VVRV6vZ6kpCSCg4Px8fERjYampiYxgUgQBLHS4bOf/SxZWVnExsa63di6KbfqrAP/vqhfmWUplUpnjW6Za0ZGRmhubuahhx5Cr9dfVVAvkUhExbN8+XI2bNhAeHi4W3cg14PBYOA73/kOhw8fFmMBycnJFBcXc8cdd5CUlERWVhYxMTEel8tms7Ft2zaOHDnCX/7yF6RSqejalUgkbN68mXXr1vHoo49eNYVgvpmYmKCwsFBs5AyXGhqvXr2aBx98kOzsbHx9fW9W3lvjw358PnbKqNPp5Pz585w7d46qqireffddZmZmcDqdOJ1O0tLSyMjIoLi4mIceeoioqCjRTe3pa8Ilw7W6G0kkErG4/la5Nl3Y7XZqamo4e/Ys586dY+vWrYSHh1NQUMDmzZt5+OGHCQoKuun1cmJiguHhYerr68nIyCAyMlLsh+r6flyP+UQQBKampkTvw65duzh16tQsQ2bDhg0sWbKEhIQEsV+yyz3uBvmv+QZuU463KhaLheHhYf7nf/5HzAKzWq2sWbOGlJQUEhMTSU9PJykpiejoaHGE1lxfMHa7nYaGBgYHB5mamhJTvUNDQ4mOjiYgIICgoCCPzr10IQgCvb29DA4O0t3dfdXrCQkJREVFkZSUdMu5JK1WK4cOHcJqtYobtfDwcCIiIkhKSnJX6v6ttdpePzd0P+v1esbHxxkdHUWn04ldpuAfzT7CwsJITExELpd7LfKPQBAExsfHmZiYEDN75XI5KpWK+Pj4D+wJ/HFxxRX1ej2BgYH4+/vPyfpxI7ganOv1enQ6HcPDw7MMLZfXQqlUikOO3bj2fDKVI1wq7t+7dy8HDhygs7MTm83Ghg0byMrKIi0tTSw78Na4eblOPlHK0YuXf3E+ucrRixc341WOXrz863DN+/nW8ol58eLFixcvtwBe5ejFixcvXrxcgVc5evHixYsXL1fgVY5evHjx4sXLFXiVoxcvXrx48XIFXuXoxYsXL168XIFXOXrx4sWLFy9X8IlvZeF0Omlvb0ej0dDV1YVGoxFnnMlkMr761a+SkpJCWFjYfIvq5UNwDdQ+e/Ys77//Pg6HA7lcTkxMDJ/61KdISEgQp63cal19vHi5VThw4ADd3d0MDAxQV1eH0WgUZ7k+9thjFBcXs2jRovkWc07wiHJsb29nZGSEsbExbDYb/v7+BAYGisM9Xf045wtBEOjr62NkZITBwUGam5vp6upidHRUHFvlGgRaW1uLXC6fd+U4MzMjjtWyWq3Ex8fPyzBhh8PB+Pg4Y2NjtLe3Y7fbkcvl4u8bEBCAQqGY80bPg4ODNDY2cuzYMerq6kS5IiMj8fHxISYmhsjISNatW0dcXJx3fqOXOcfpdIojqbq6ujAajZjNZmw2G3Bp3qRaraaoqGjOp2O45j4ePXoUrVbL8PAwFy5cwGw2i/2oXaOzCgoK3Npec2ZmhqqqKqamprDb7UgkEtLT06/qWuZ0OsXhza6+yS5kMhmpqakkJyejVCrdIpdHlOPu3bspLy+noqICvV5PTEwMGRkZPPzww6xfv17sFTqX/UtdjdGdTic2m43jx49z4sQJjh49Sl9fnzg5ZPPmzcTHxzM0NERtbS3vvvsuYWFhLFiwYM5kvRKn08nw8DAajYbe3l70ej0PPfQQMTExs46TSCQetYoEQWB6eprz589TWVnJSy+9xOTkJGFhYWRlZfHwww+TkpJCXFwcOTk5cyYX/GM8z7lz5/Dx8UEmk4nf2xtvvIHT6cTPz4/h4WE+/elPU1xc7G0X6GVOEARBvHeGhoZoa2vjj3/8IxqNhv7+fnF2ZnR0NMXFxbz++us3NNz4ZhgZGWHr1q1s3bqV4eFhsXfu5c3Jq6urUavV3HfffW7t0To2Nsa3vvUtOjs7MRqNSCQSvvnNbxITEzNrXJfNZmNsbIwtW7bMmssrkUhQq9U8/fTTfPGLXyQ1NdUt641HlKNrOKlrVtnQ0BDj4+M0NDTwpz/9iaKiIjZs2MCaNWuQy+UeV5JWq5Wqqipef/11mpqaMBgMjIyMoFAoCA8P56677uLOO++koKCAsLAwfHx8uHDhAgaDgYMHD4rzHucanU7HxMQEQ0ND/OhHP6K3t5epqSmUSiWVlZUEBweLx6pUKmJjY9m8eTMxMTFu2z1djiAITExM8Kc//YkDBw6I7uexsTFOnz5NQ0MDERERhIaGEhsbi1QqFcfkPPnkkx4dVxYSEkJmZibr169n9erVSKVSVCoVZWVl/O53v+Ps2bM0Njbym9/8hnfeeYclS5bwxhtveEQWL15cdHZ2otVqOX78OLt372ZkZES0xEJDQ4mPjyclJYWLFy8SExPD3XffPS/NwcPDw/nc5z7H6dOnxRm4arWatLQ0EhISSE5OZufOndTV1VFTU0NZWRl+fn43fd7m5maqq6vp7u6eZQ1u2bLlmgpOEATMZjMSiUScEgSXRqht376d8fFxVqxYwec+97mbls0jyjE+Pp5FixYhk8mIiIgALpntHR0dDA4OUllZycTEBBaLhUWLFnl0PiFcGpsVGRlJRkYGDocDg8HA4sWLiYmJIT09nczMTDIzM4mOjhZ/cEEQGB0dxcfHZ85iVDMzM+LMxJ6eHnQ6HQaDgfHxcVpaWkT/v8lk4vz587NuIoVCgVqtxtfXl/vuu89j36nT6cRsNouTxeGSq9Vut2O1WrHb7aJCB1AqlbS3t7N69WpSU1M95s7MzMxEqVSyYMEC0tPTkUgk+Pv7k5KSwn333UdGRgZpaWkcO3aM8fFxmpubaW5udqsb5l8dQRAYHh7GaDSKC5larSYwMPCm5g7+K2Kz2aivr6eiooILFy7Q0NCAwWAgOjqa9PR0MjIyCA8Px+FwcOTIEWJjY0lLSyMvL29epprI5XISEhJ49NFHaW9vR6fTERgYSE5ODrGxsUxMTCCTyTCZTPT39181mvBG0Wq1VFZWMj09jdPpFJXd5evLB+E6ViKR4HA4GBsbo6GhAbVazeDgIJGRkTe1dnvkV0hPT0cul5OZmSkuVJOTk1RUVHD48GF6e3vRaDRirCo5Odmj1qOPjw9JSUksW7aMpKQkTCYTsbGxJCcnk5mZec0dkNlsZnBwELlcPif+f9dg4erqaqqrq6mtrRVjoK5hqHBJ0dvtdnQ6nThj0YVcLsfhcLBs2TKPbzhcuIa0wqWL1GazYbFYxOnjTqeT1tZWOjs7CQsL85hyTEtLIy0t7ZqvrV27luzsbFJTUxkYGKClpYXBwUHOnTsnzoX7pGOxWHA4HOJsxJmZmasWQLvdjkajYWhoSPSmJCQkkJiYiFKp9Ph9cuX8Rtf8WFfM7vLjbDYbDocDHx8fAgIC8PPzc4ulcz24XKjl5eUcOHAArVaL2WwmOzubwsJCVq5cSVlZGTKZjL6+Pk6cOEFGRgZ5eXlkZGTMi7vfNeT8oYceYmBggM7OTvz8/EhNTUWpVHLgwAF8fHyw2WyYTCY+YmDFddPd3c358+ev+g2vJZ+Pjw9yuVy8Vu12u/i60+lkamqKjo4OYmNj6e/vJyws7NZTjsXFxRQXF1/1/KZNm2hqamLv3r38/Oc/Z8+ePSxYsICSkhKP7jxdsxFXrFhx1fPXwmKxYDabMRqNczafzuFwMDg4yK5duzh8+LAYp5BKpfj5+RESEnKVvBaLRXRdwyX38dmzZ2c952kSEhJQqVTinMTx8XHGx8cZGBiYdVxXV5cYMJ8P4uLiiI6OJi4ujp/+9Kfs37+fQ4cOsWTJEnEA7CcVQRA4deoU/f394qZm165ddHZ2XnWsXq+fpTiVSiV33nkn3/ve91iwYIFHF3a9Xs/IyAjj4+MADA8P09/fT319/azPotfrqaurY2BggOjoaJ5++mnKyspYvny5x2S7HKPRSEdHB7/+9a+JiIhgxYoVPP744yxZsoTAwEB8fHyYnp5mx44dHDp0iLNnz/LKK6+wdOnSeb8WQ0JCCAkJISsrSxx0vW/fPn7zm98wMDDAbbfdxooVK9zm+lUqldcVX42JiSEpKYnly5dTXV1NV1fXNWfNjo2NMTAwIM6DvJkNm0dW/Q9SOhKJhJSUFAoLC1m7di379+9nenp61g7Ak3yUdSoIAjabjaqqKioqKtBqtXzlK18hNTXV47JJpVLCw8PJy8tDr9czOTmJXC4nLS2NkpISFi5cOGsX1NjYSG1tLbt27cJqtSKXywkPD+eZZ54hPT3dIzJKJBKCg4O59957SU1NRSKRkJ+fT0REhJjNOzAwQG9vL9XV1Zw4cYKRkREcDgf79u0jOjqawsJCj8h2vbiGSQNu2/3+M1NfX8+f//xnzp49i8lkEu/Fvr4+MbYjl8vx8/NDLpfj7+8vZl1arVbMZjPnz5/nV7/6Fb/+9a8JCAhwq3zHjx9neHgYq9XKsWPHGB4exmAwIJVKkUqlOJ3OqzaDrvsmOzubnp4e3n77bVFRpqSkeNwya2ho4NChQ0RHR3PfffdRUlJCQUGBuIE0GAz85Cc/4eLFi8zMzPDcc89RUFAwLxnUdrudvr4+xsbGxE0HXLLE+vv7OXHiBGfPnqWvr4/Vq1ezdu1a4uPj3RZqSkhIoKCggIqKCiQSCUFBQWRkZIiv+/r6smjRIhYuXEh4eDgTExMcOHAAvV5/zfdbtmwZq1atIj8//6Y9GXPu3A4KCiIiIoK4uLhbpt7M5Z6Znp5Gq9VSUVGBRqPB39+fwsLCq7JCPYHrwigqKkKhUDA+Po5CoSArK4vS0lLy8/ORSqU4HA4mJibo7e2ddZOHhISQmprKnXfeKcZ5PSGjQqGgsLCQxMRE4JILPSwsTLT8dTodkZGRDA8Pc/r0aVEBjY2NMT097RG5PorLrdna2lqGhobw8/MjJyfnE+9SnZiYoK6ujosXL2K328X4fFRUFFKpVPS6hISEoFKpsNvttLe3i1mWdrtdnDjvic1GXV0dPT09KJVK+vr6mJycZHp6GqlUSnR0NAqFgtDQUPF4132Unp5OcHAwGo2G9957j6amJjQaDYmJiR5XjiaTifHxcZYsWcLSpUvFRL+pqSlGRkbQarWcOnUKpVJJWloa69evJyoqas7cvi5sNht1dXVoNBoGBgYYHR0VXxMEAZ1Ox5kzZ+jo6CAwMJDi4mIKCwvdugGKiooiOzubqKgo1Go1MTEx5Ofni6VrU1NTxMfHExkZiUKhoKWlRfReuHCFdsLCwigrK6OkpEQs4boZ5qUJgMPhwGKxEBoaSkhIyLxkZ7kQBAGLxSL6q3/84x9TWVmJSqXijjvuYNWqVXNSs+dahD772c9+6HEmk4kTJ07w29/+Fo1GI2a+ZWdnc9ddd7F48WKPxm9dG4YPw7VIulzDLvkiIyM9JteHUVVVxaFDh/jb3/7G6OgogiCQlZXF9773vTktJ7oVCQkJIT8/H7i0WAYGBvLQQw+hVCrx8fFBIpEQFRVFQkICSUlJWCwWXnzxRXbt2iVaGosXL+b555/3yEajqqqKoaEhVq1axde//nVkMhkSiQQ/Pz8WLFhAeHj4R77HHXfcwcjICEeOHGHVqlUeV0LR0dEsXbqU2267jejoaPF70Wq1HD16lDfffJPx8XGeffZZNm7cSEJCgkfluRaCIDA5Ocm///u/09zcLLrTr4VCoSA3N5cNGzZQUFDgVjkSExMRBIH169ezcuVK0tPTSUhIoLW1ldraWmpqaqiqqqKqqgqTyURjYyMGg0GMUbo27OHh4dxxxx089thjZGVlueU3nnPlWFVVxf79+9m9ezcbNmwgLy/P7a6YD2N6ehqdTsdf/vIXBgcHMRgM6PV6BgYGmJiYYHx8nOjoaNavX8/3v//9W8aymJmZYceOHRw5coSTJ08yNDQkFro/88wzrF69mpKSkjlb7F3p3g6HY5bFUFVVRWVlJdu2bRPdXz4+PmzYsGFW7aOncDqddHd3U19fT2trKzU1NWKDB5crJiIiQrR8P+nk5uby3HPPYbFYgEvu/aCgILG2DRDrRqenp/nJT37Cvn37aGpqAqCoqIji4mKSkpI84gn6+c9/jt1uJzAwEKVSOStD8cMWQKfTydjYGO++++5VXhZPk5OTQ2pqKgqFAl9fX6xWK0NDQ/zyl79Ep9MRHBzM888/T25u7px4pa7FwMAA9fX1NDQ0iGGGDyIwMJBPfepThIeHu/03Dg4OJjs7mxdeeIG6ujqOHTvG1q1bsVqtzMzMzLIQXe58V7xbIpEQGxvLI488wj333EN2djZqtdptm585UY6uuketVsvevXs5ffo0BoNBTGeey9273W5nbGyMM2fOoNPpxGzQyclJpqamcDqdKJVK+vv7aWpqIiwsbM7dHS6cTicmk0nc9ZaXl1NXV0d/fz82m43Y2FiKi4tZv349OTk5c9LFx9Whoqenh/Pnz2OxWMTsQYlEQltbG21tbeJONDQ0lKysLJKSkmbVZbqboaEhOjs7aW1tpb29na6uLnQ6HVqtFoPBwMzMDHa7HUEQCAwMJCws7BNvNQJiF6EPw2Aw0N3dTWtrK+Xl5fT09ODr60tBQQH33nsvpaWlHstUjYuLA5ilrD+KyclJGhsbaW5uZt++fUxNTZGamjpnZRJyuVz0hk1OTtLb20t5eTn9/f2o1WoWL17MggULCA0NnZeyDbgUatBqtczMzIj3rwuZTIa/vz8BAQFMT08jkUjo6OjAbDbPqi10B1KpFLlcTnR0NBMTE3R0dNDR0fGR/xcbG0tubi5Llixh9erV5OXlXZcX4ePgkV/m8m40rrrCvr4+9uzZw7Zt2xgZGSEwMJCMjIw5D0I73fIZNQAAIABJREFUHA5MJhN9fX0MDg7icDjw9fVFoVAgl8uZnp5mcnKSuro6XnvtNRYsWEBYWNictXNyOByz6gZ7e3upq6vj+eefZ2JiQnSjwqVg9gMPPMDy5ctRKpUej+EKgoDRaKSqqoqTJ0/y7rvvii2fXDeNSwbXzj4lJYVNmzYRGxvrUStcq9WyZ88e3nzzTbq6umYp7Mu7fQAEBAQQHByMyWRCoVB4O+V8CIIgMDAwQEVFBfv27aOqqgqpVEpcXBybNm3iscceIzo6+gPjjTe7kF7PNe26X5xOJ3a7nc7OTnbu3MmRI0doamoiISGBtLQ0li9fPudt2fr6+nj//fd55ZVXCAsLY+nSpWzatInw8HB8fHxwOp3zknuh1+vp6+ub9ZxEIkEmkxEcHExERAQJCQmiR628vJwvfOELJCUleaxt5f9n78yj4zyrNP+rUqlUqk27SvtuWYtlyZZkO5Y3ObETr0lMmtAhpMkhQwKn6XSGw9IhZ4YeCAwNBxqGSXeHQBgSHEKwg8GJ91jybmu1FmvfS7tKVaXa9/nD5/uwvMVOVJIDes7xiR2rXG999X3vve+9z30evV5/w5puhYyMDD796U+zZ88eNBpNUL7XoATH8fFxxsbGxI399OnT4nyUx+OhrKyMp556igceeGCWPNB8IDIyksrKSs6dO4fFYsFisZCQkCA20Zubm6mvr6ehoYE//OEP+P1+Pve5z7Ft27agrkuYc2xra+PKlSscOXKE6elphoeH6enpuSnh4cqVK3z3u98lLCyMlStXBn220ePx0NDQwG9/+1vOnDlzS5axVCpFrVbzj//4j2zYsIENGzYgk8mCdlILBAJUV1dz8eJF+vv7b8hur/+9ILQwPj7O17/+dYqKikQm4SL+Aq/Xi9ls5s0336S6upoLFy7g8/nYsWMHW7Zs4b/9t/+G2+3GZDLdlGylUqlQKBRB1QC22Wx0d3dTXV1Nf38/fX19VFVViSee5ORkvvrVr7J27Vry8vLmvVqwf/9+Dh48SFtbGytXrmRkZISzZ8/S19dHdHQ0MTExQWOX3w7Z2dlUVlby6quvipJtMTExlJeXs379enbv3k1KSgr19fWcOXOGF198kV//+teMjo7y+OOPB2VN0dHRd3xYstls6PV6JiYmkMlk93ZwHB0dpaenRxzyN5vNmEwmpqenGRsbw2QyiaeeiYkJzp07x0MPPURiYuK89hzhag8lPDyc0NBQsZchl8tRqVSoVCqSkpKIjY1lYmKCmpoaUlJS0Gg0QZuTEtinr7/+OgMDA0xOTqLX63E6ndjtdrEfdD2cTqfIMpsPJqjb7eb9999Hr9ffdvwmNDSUtLQ0ysvL54RSfScQMtxAIIBGo0GlUoklXZVKJdL+Ozo6GBgYwGg0UldXR2dnJzqdbjE4Xgen00lHRwe//OUvOXPmjKiKIpfLsVqtdHV18ctf/pKJiQkMBgMTExM3BJ6EhASio6OJi4ujuLiYlJQUEhMT7/qkLrCMHQ6HaGgwOTkJXL0nDQaDyGS1Wq04nU7CwsKQSqWYTCb27dsnqnOtXLmSyMjIeeMSaDQaoqOjiY2NFRWv2traCA8PF39FRUWRnp5OdnY2paWlZGRkBL2aERkZSX5+Pv/0T//EyMgIISEhlJaWkp6eTlJSEsnJySiVSvLy8pBKpWzduhW9Xk9bWxtutzsoraa1a9cilUrp6enhypUrs6pk10Ov1/OnP/2JwcFBCgsLKSgomPMDzJwFx4mJCRobG3nrrbcYGxvD5XLh9XrRarXiDJ5MJsNoNGK322lsbKSmpoaSkhIyMjLm/QQJV2dohJp/aGioGCyjo6NFZZc333yTuro6dDodFRUVQck8TSYTXV1dvP3225hMJjwej8gUVCgUJCcnz1L4GB0dxWaziadJ4VoHEx6PB7PZTF1dHQaDQSxbKpVKvF4vTqcTiUQi/v+wsDAiIyPnzZ1DrVYTFxdHeno6iYmJxMXFkZiYSFlZGVqtlpCQEHw+HzqdjqamJjo7O+nv76e1tVWU7lrEXzA9PU1bWxvvvPMO09PTs+6vqakp2traaGtrY3R0VHS3CQsLE0ubcFVGMjo6Gp1Ox/T0NAUFBeTl5ZGbm3tXz5Hdbqe3txeLxcLIyAjDw8MMDQ1htVpFJZzw8HCR8X2t6pHQHxcENfx+v5j8Cj8XzECUmprK8uXLCQkJob+/H7vdzvDwsEgs8Xg8eDwecnJyKC4uxuv1Eh8fLyZ0wUJ4eDiJiYk8/PDD6PV6QkJCWLt2LRqNZtb7xsbGEggEWL16NYcOHaKvrw+DwSCO+swlBHnPjRs3EggEmJ6eZmZmBrPZfEPVzGAwYDAY0Ov19Pb2MjQ0JPan5XI5Wq2WyMhI5HL5R+7rSj5kNumOB5fef/99jh49yk9/+lPgamlNqVTy0EMPsXTpUpKSkoiPj2fv3r20tbXR19eHVCrli1/8Ik888QSrVq36SB8gWLDZbAwPD7NlyxacTifZ2dmcOXMmKDdsbW0tR48e5X/+z/8pnmoFzcr8/HzWrVvH0qVLycjIwOl08tJLL3H69GlMJhNyuZyf//znrFu3LqhsUL1eT2NjI1/+8peZnJwUT7MrVqzAYrHQ1dUFzC5hfvOb3xTHYYINo9FIT08Pvb294pzTzU4HgjNCY2Mje/bsISIigl27dvGb3/zmbt7uk8rkuePned++fRw9epTXXnvtLy++Zq+49nsWytg5OTmzWMHX93p1Oh1FRUUcPHjwrqoJFouFoaEhPB6POB7kdDo5e/YsExMTaLVaceRKSChVKhV2u118r46ODt577z2MRiMJCQnk5uby3HPPsWrVqjknctwKV65cYWJigqmpKYaHh+nv76e/v5/6+nomJibw+/2o1WqOHz9OdnZ2UAlsdwOr1UpVVRX/8i//glKp5J//+Z959NFHg1ou7+jo4OzZsxw9epR9+/bdIGV4q3sRrvYjd+7cyac//Wmys7PvhBF80+d5zk6OaWlpVFRUiEdhwSVi69atYtkyNDSU4uJiWlpaOHz4ML/73e+ora1FqVTec8ExPDyclJQUvvCFL4jKHHq9Hp1ON+dzmXl5eURHR4s+iNHR0eTk5IiBUqVSYbPZ2LdvHydPnuTixYvYbDYyMjKorKxk69atQZedio+P57777uPHP/4xFotFnDPKyckREwmTycSBAwe4dOkScGdkirmCVqsVKfRqtfqW2aJCoSApKYnQ0FC+/e1v8+abb9LV1cWBAwd48MEHF8Qj817EypUrsdvtHD16FLjKGs3MzBQDoUajYc2aNbOcVqKjo3E4HGKJ3+1209rayi9/+UtGR0eZnp6mq6vrrsUCVCoVWVlZs1iVfr+fzMxMscqi1WrF+00YH/L5fDzxxBNIJBIcDgef//zn+dOf/kR3dzfDw8N89atf5b777mPFihU8+OCDZGZmBrUFkJmZSWpqqnhadLlcolTl3r17uXDhAhcvXuTEiRPA1cTzXoBSqWT9+vXk5uai1+s5efIk27dvD+qzkp6eTmRkJGvWrOHRRx8VjSCOHj1Kc3OzeKq8WQVidHSUd955h4aGBh555BH27NnzkfgYcxYcBVUWofSn0WiIiYlhyZIlsz5AVFQUCoUCr9fLqVOnMJlMXLlyBZfLhVwuv2fo9VKpVBx4b25uZmBgAJPJRHR09JwHR5VKRXJyMps2bSI8PByNRiOWCOAqMeLChQvU1NTQ0NCAyWRCqVSSkZHB5s2b0el0Qd/U5XI5UVFRrF69epa2ZlxcHG63m+zsbMbHx7l48eIsxup8QRCY/rD+tcCijYyMZMWKFezbtw+n0ynK3C3iKuLi4igsLGTPnj1IpVLi4uJISUkRGehyuVxshwh9tbCwMLxer1hWbW5uRiKRiOV/obd2t/eF8Cxejw8r2YeGhpKQkCD+OSUlBYvFQnp6On19fdTU1Iimw06nk0ceeQSdThe0E9vtWkfV1dVoNBp8Pt8NCjALDalUKipw2e32OXXluBUUCgVhYWGiUIygmSuXy0lISGBsbIzJyUm6u7txOp14PB7x3nS73UxMTOB0OomLi0Oj0bBq1SoyMzPvSsN7zoKjTqdDp9OJahu3Q2pqKjqdjv3791NfX09HRwdWq5WIiIgFm/u5GSQSCfn5+URFReF0OjEajR+qHv9R3ycsLOymmaIwevKf//mfXL58WSQ+xMXFsXz5ch555JF5UxiSSqW3VPNISEj4RFkXhYSEEB8fj1wunzdt308S1Go1K1euvKkakmCj1tnZicFgIDk5eVbPNhAI4PP5uHTpEqdPn2ZsbIyQkBDy8/PZtWvXgslGymQyKisr2bRpE06nk8uXL/PDH/6QS5cucejQIaKioli7di0FBQXzvjZBqxYIutmBx+MRtWnvJlEpKCjAZrPR1NQ0L7rEwmiJcFBISUlh2bJlrF+/nvHxcfR6Pa+88grj4+PYbDZcLpc4z+z3+5mZmaGqqor29nZ27NjBk08+SVFR0R3ffwsWiSQSicgaW6hZnw+D3+/n1KlT9Pf3L8j7T05OcujQIV599VXq6+vxeDyoVCpKSkp4+eWXWb58OSqV6p45bX+SMDk5yfPPP09XV9eCOYV8UvHOO+9QVVXF+Pg4//RP/zRL29ThcDAyMsL/+T//h/fee4+hoSEkEgmVlZX83d/9HY899tiCz5UKkmNlZWW88sorVFdX85WvfIXvfve7PPfccwsSHPv6+hgaGkIqlbJu3TrS09OD8j5+v59nn32WnJwcHnjgAcrLy+94/xB4IwsNwQrR7/ezc+dO/H4/DoeD+vp6Dh06RENDg9jasVgsOBwO9u3bh8vlYsOGDTz22GN39D4LEhwNBgMdHR00NjYCiFJLC/3Q3AxWqxWfz4dCoSAyMnLOehJutxuLxSL2x6797Farlfb2dqqqqjh//jwdHR24XC5ycnJYunQp27ZtY8mSJWi12r/pwDgwMIDL5SIqKuqOvNsECx6TyUR/f7+oEKLVaiksLJz3AfFPIgSlK8GPNTIyEq1WSyAQYHh4mMbGRhoaGqiqqmJqaorIyEjy8vL4zGc+Q2lp6T1DMgHE2VuB5DM1NcXMzMy8rsHhcNDS0kJPTw9Go3HWmFmwYDQauXDhAuPj4yQnJxMTE3NHbZm+vj4GBweDtq47heDtCIhVM6/XS0lJicgpMBgMDAwMiGX+qakpTp8+TSAQuDeDYyAQwG6309/fz6lTp2hra6OgoID8/Px7kgghKMIEAgGRQToXN63H48FoNNLZ2Ul2djZqtZrw8HDcbjcul4uRkRGqqqp466230Ov1mM1m4uLiWLlyJRUVFezevftjG3neCZxOJwaDgbCwMJRK5S1nw1wul6iCZLFYbpCjChY6OjpELdySkhKRzn897Ha7SICoqqpieHhYnDkT+mB5eXmLwfFDILBEjUYjU1NTxMbGYrfbMRqNWCwW0arpzJkzdHR0EB8fT3Z2Nps3b2b79u3ExMR87ARYKNkaDAZxFEvQfhUk5q5VRxKeEUFxShg1EdxEBgYGxNOtYM01X/B6vZhMJk6dOsXAwAAOh4OYmJigHxR8Ph9dXV309vbyzDPPoNVqb7n/Cn08m81GW1sbAwMD99xz4vf7RZ3VyMhIAoEAR48eZWhoSPx7oRx8N/PM8xYc/X4/drudP/7xj1RXV/OnP/0JiUTCxo0bP9SJYiEQCARwu92cOXOGsbExIiIi5szHrKuri+PHj/P973+fb33rW+Tl5REXF0d7ezsXLlygpaWFM2fO4HK5xDnHH/3oR5SWlpKamjpvJ+wLFy7whS98gfXr1/Poo4/y8MMP3/TnLl26xOuvv85bb701S7Ag2E379957jw8++ICpqSl++MMfkp6eLopTXztG8Ic//IG+vj6Gh4e5ePEiHo9HbOz/4Ac/oKKiYkG89D5pkEgkREREkJOTQ1paGmfOnOEf/uEfxMBkNptxuVyiz+f/+l//i1WrVhEdHT1nFQ673Y5er+f5558nKyuLxMREkpOTxUqKQqHAZDIRCAQICQkRe+DDw8PU19eLghtDQ0O0t7eLnpXR0dE8/fTT8zJ2BFf3l6GhIerr6/m///f/Mjo6SnZ2Np/+9KfJyckJujBKfHw8CQkJpKWl3VYQwWw2o9fr2b9/v7hnP/jgg/cMN8TlcomlU7h6uq2rq6Orq+tj7z9B+4RjY2OMjIyQn59Pc3MzLS0tHDt2jI6ODiYnJ7FYLDz77LPcf//9QZM9GxwcFP3fYmJiiIyMnEVekUgkhISE3JA1mc1mBgYGuHTpEs3NzaJqzlw94L/+9a85ceIERqORX/ziF2i1WuRyOdPT05hMJqxWK36/n1WrVrFmzRoefPBBVq5cOYs2P1/w+/1if+n8+fOo1WoeeOABVCoVBw4cwG6309HRwaVLl/B6vSgUCtRqNZmZmaxatSqow/WCObXRaORHP/qReHIUEhihlz06OorD4RBZbZGRkeTk5PDSSy+xcuXKoPlf/jUiJCREnG0dHBzEYDCI4xQajYa1a9dSWlrK9u3bWbJkCREREXNa+hfKZi+88AJtbW2Mj49z6dIljh8/jtVqxWq1imbHMTExWCwW2tvbMRqNmM1mvF4vSUlJ6HQ6IiMjWb58OWlpaWRkZJCRkTGrfxoMeDweLBYL7777LqdOnaKpqQmDwcBjjz3G6tWreeCBB4JeRcvMzKSmpobz58/z9a9/nfT0dFJSUigpKSE+Ph6Xy8X4+Djvv/8+fX19jIyMiLyLkpISPvOZzwRdtEVQXOvu7gauBvPExERWrFhBU1MTIyMjojrYlStXGBgYAK6WqY1GIyaT6YbgmJube0eEUQFBCY4Gg4HW1lZqamoYHh7m8uXLtLS0cOLECaxWKwqFguzsbDZt2kRubu6cq6j4fD7sdjvV1dVMTExgt9tvGhwF9fno6OhZJ8KRkRF6enq4cOECVquV3NxcysrK5mx9HR0ddHV14Xa7aW9vn1X6ERifS5cuZcOGDaxdu5YNGzbMu8SexWJhZmYGn8/HxMQELpeLsbExtFotfr8flUrFsWPHsFgsonxXWFgYWVlZZGZmUlJSQk5OTlA3m4SEBHQ6HR0dHTQ1NQF/GUi/9vfCfyUSCampqeTm5rJixQo2btyIWq2+J3vd9yokEgnp6emUlZXR398v9sNDQ0PJzs6mvLyc0tJS7rvvvqC8vzCyU1ZWJmr4jo6OznqGtFqt+Mvn84nPjlAdyM7OJj09XWSIp6amirOvcwW/3y8qCwnr7O7uZnp6WpzXa2pqYmpqiuzsbDZu3EhZWZk43xwsSCQSli9fzsDAAM3NzRw/flz8/OPj4+h0OpxOJ+Pj4xw+fBi9Xi+KOmzYsIH77rtvzt1NhGs1MTEhGhyPjIzQ3d1NR0cHcHUaIjk5GZPJRENDA3q9npGREZE1LZRQbwZBkKa0tJTy8vI7XldQgmNdXR2/+93vePPNN5HJZHg8HpEur9VqWb58OXv27GHLli1B0Ti02+309fXx0ksvMTY2Nmv84loKskqlIioqStQPFDbVgYEBDAYDU1NTpKen8/DDD/P000/PWQYsDAELv4e/jHPk5+dTVlbGZz/7WZYvX74gsnpwtTzR3d0tnmInJiYYHx9HIpFw7ty5WT8r1PzVajW7d+9mz549c5pM3AqbNm3C5XJx6tSpG/7uZgoacrmcXbt2sXPnTnGAfRF3j+zsbNLS0lixYgXNzc04nU7Cw8PZvHnzvPSjpFIpMTExbNmyJejv9VHh8Xi4cOECMzMzKBQK8vPzefnll2ltbWV4eJiZmRlSU1NZsWIFn//859m6deu8KPVIJBIef/xxzGYztbW19PX1iRZRb7311k1fo1AoyMjI4Pnnn6e8vHzOE16Xy8WFCxc4cOCAKO0oSOsJ4y0ymUycd71Wek/4TLeDTCYjIyODz33uc9x///13vK6gBMfW1lb0er0YFMPCwoiLi6OiooKHH36YgoICcnJygrbxq9Vqli5dyte+9jWx/6DT6cQyjNVqBf6i4GIymUTR6pycHHHgOTk5ma985Sukp6d/5NOt3+/n5MmT5OTkiPTsZcuWiWajxcXFREZGEh0dzZNPPkleXh7x8fGo1eoF85EExFKToM5zK6SkpJCVlUVxcbGoRDFfZcrS0lLS0tIoKyvj9OnTYumsurqamJgY0XanoKCAhIQEEhISKCsrQ6PRzNts6F8rhAH76Oho8WR+rxE1FhI2m42f/vSn6PV67HY7MpmMyclJUlJSePjhh9m0aRP5+fmkpKQQGRk5r0mwSqVi586dpKWl8cEHH3Ds2DF6enpuSCjT09MpKiqiuLiYRx99lJycnKBoJdvtdvbv309tbS3Dw8Pi/nwtsU84XAkzjLeDVCpFJpORlpbGpk2b2LRpE7GxsSxfvvyuTrxzHhyFRrPJZCI8PJzS0lLy8/NJS0sTy1nx8fFBpXQLKigVFRWi0oRGoyEzM5OZmZlZpBG/34/FYhGNPHU6HXa7ndDQUGJiYsjNzZ3lQP5RIDDQBGzevJmEhARWr15NXl4earUajUZDaWkpcXFxC3ZavBZKpVJkgVZVVd0wKC+TydBqtezYsYOCggKWLl1KYWEhKpVq3oK6kHStXLkStVqNzWbD4XCIFlSCFF9ycjJarZaIiAji4uL+psdf5hLC2MEibkRISAg6nY6pqSlcLhdhYWFUVlZSUFBAeXk5hYWFohrPfM94SyQSEhISkMlkojTf5OTkDcExJiaGlJQUUlJSWLJkSdA8YxUKBZs3byYqKorR0VEMBgM1NTUiy/xaCIHxViIEERER6HQ68vPzWb16NYWFheTn5xMeHn7XlaI5Ex4XXxAI8Mwzz9Da2orJZOKLX/wiDz30kFi6/FuE1Wqd5aohDK0aDAbi4uKQy+X3ZN9LMI39r//6L1EZX/gOFQoFqampfP/73yc/P5+YmJgFXu284pMaXYMva7II4Opp6Fe/+hV1dXVMT08TExPD7t27RVeSv9W98HZoaWlheHiY0dFR/uM//oPx8fHbWvFd79sKVzVZCwsL2blzJ9u3b7/T5O2mz/OcB0dglnq+UCtezNZvxM2+3HsJgUBglgXR9ZBIJOL3+zeGe/dLuz0Wg+M8wufz4ff7xedcsKG7l5/5hYQQM4RZ1o8iUSdc35CQkLvZl+YvOC5iEX/l+KTubovP8yIWcSNu+jz/zaX8i1jEIhaxiEV8GBaD4yIWsYhFLGIR12ExOC5iEYtYxCIWcR0Wg+MiFrGIRSxiEddhMTguYhGLWMQiFnEdFoPjIhaxiEUsYhHXYTE4LmIRi1jEIhZxHe4NU655hGDcaTab8Xg8oq2JXC4nNDQUpVIpmqfeiwbMi1jEQkMQhnA4HJjNZlE0X9ADvle8/u41jI2NAVfVpSIjIxd4NZ8c2O12fD4fPp9PtJ0T/hwVFYVKpQqKVvLfnAjA6OgoBw8e5NVXX6W/v5/p6WngqtdXbm4ulZWVxMTEkJOTEzTbnUV84vE3LQIwPT3NyMgIZ8+e5dVXXyU0NJSVK1fy6KOPimLai7gRf//3f49EImHNmjV86UtfWhRqvwN4PB5OnjyJwWBgbGyMixcv0tvby+TkJCaTiX/+539m586dlJaWfpy3uenz/Fef4gnejg0NDbz//vu0tLTQ39+PXq/H6XSKEkVDQ0MYDAba29tRKBSi6Ph//+//ncTERDQaTVDWNzMzg9vtxmq1cuzYsVmK8319fYSHh6PT6UTJqdDQUJKSkigoKCAmJmbefR4/CRBE5B0OB319fXR1dREXF8eKFStQKBRMTk4yOjrKpUuXMBgMoh/ll7/8ZQoKCkhNTV3oj3BPwul08otf/ILz58/T29uL2WxmdHQUuJp02mw2nnzyycXgeB2EatXIyAh+v5/4+HiOHTuGXq9namoKuOpXmJWVxapVqz620cHt1mG327FYLOI+4/V6qaurY2RkRPw5l8uFxWLh3LlzokPRqlWrRHeLYMLr9WKz2airq+PcuXOcPXuW0dFR3G43crmcxMRE1q1bR2hoKBaLhf3796NQKFCpVOTl5c3pWj5WcPT7/Xg8HjGKW61WzGYzKpVK1FMNCwtDpVKhUqmIiYlBoVDMm7agz+djZGSE3t5ejhw5wrFjx+jr68PpdKJQKGYFPKFUNDY2htvtRqFQMDQ0RElJCWvWrCEvL2/Oyqx2u52ZmRlGR0fp7u4Wb9jq6upZ7tUDAwMolcpZFlByuZyEhAT6+/tJTk4mMzOTnJwc5HJ50DVO/X4/U1NTTE1N4fV6iY6ORqvVivqqVquV6elpLBbLLf+NkJAQkpOTiYiImHP3DrfbjcVi4cyZM7jdbmw2G4ODg5hMJuLj47FarbjdbiYnJxkfH6eurg6j0cj09DRjY2Ns3rwZnU63GByvg9frxWw2o9fr+eCDD6itrWVsbAylUonD4RA33f7+fmZmZuZlTU6nk7GxMYxGo+h8ISS61+8vkZGRJCQkkJWVNe86wBaLhampKZqbm5mYmMDtdqNUKgkEAuj1egwGA3DV6b6oqIjIyEiKiopuKE0LQUOj0Xzkz2CxWGhra6OtrU10u/D5fDQ2NopJDlx9jmZmZrh06RJxcXEkJyfj8XgoLi4mKioqaCYJXq8Xg8EgmjDX19fT1NREfHw88fHxREdHU1BQQElJCaGhoRiNRn73u9/R2dlJb2/vvRMc/X4/drsdo9HIiRMnqKuro6Ojg7q6OpYsWUJYWBghISHEx8eTk5NDTk4OGzduJCkpCblcPi8B0uFwcP78efbv38++ffvw+/3I5XIiIyPJyMiYVacOBAJ4PB5mZmYYHBzEarUyMzPD//7f/5tnn32W6Oho0tLS5mRd4+PjXL58mX379vH+++9js9nweDy3vOmuFygXBMGzsrLYsmUL3/zmN4mPjw96j9Tr9VJbW8vJkycxmUxUVFSwfPlytFotoaGhdHR0cObO6F7iAAAgAElEQVTMGdrb22etVYBEIkGpVPL4449TWlpKfHz8nK7PbDbT3t7Oc889h8lkEu3KBBPe3//+97S0tIhC6tdupiEhIfT09FBYWDina/prgMViobGxkRMnTnDixAkcDgehoaGkpqbS29srJnTzFXh8Ph/j4+McPHiQCxcucOLECQwGwyx7o2ufl7Vr17Jjxw6ef/75oJir3wqBQIDe3l4uXLjAT3/6U/r7+3E6nfT19XH8+PFZ18vn89HS0oLP52PJkiU3+CY6HA56enpYtmzZR04q9Xo9b7zxBr/97W9vmcBev89MTExgNptxuVzs2bOH5OTkoF1Di8VCa2sr//7v/051dTVKpZL09HSeeuopKioqyMzMJCIiAolEgsViob+/H7/fT19fH01NTWzfvn1O13PXwdHtdmM2m/n+979PY2MjfX19zMzMiO72brebxsZG8SKHhIQQEhKCTCZDo9HwzDPPsHbtWtatWxdU379AIEBPTw+nTp3ivffew+/3s3r1alauXMlDDz1EcXHxDcHE4/EwMTHBsWPHOHv2LH/+858ZHR3lF7/4BTU1Nfzyl79Eo9F8bMKB1+vFZDJx5coV7HY7eXl5lJaWUllZ+aFZ2czMDEePHuXcuXMMDw/z1ltvUVZWRkVFBUuXLv1Y6/ow+Hw++vv7xQBYXV1NdHQ0EokEn8/H4OAgLpdrlovH9dm8TCajo6ODf/u3f5vz4OhyuTCbzTgcjllrOHfuHDKZDJlMRm5uLhKJBLfbTWdnJ3DV/DU5OZnPfe5z5OTkzOma/hpw4sQJDh48yIEDB3A4HKjVapYsWcI3v/lNvvGNb9Db24tUKmX9+vXzcuo2Go089dRT9Pb2YjKZRGd4iURyU6eburo6lEolJSUl3H///fPiN+pyuThy5AivvfYaNTU1GAwGwsLCyMvLE70GCwoKSEpKAuBrX/sabW1t/OpXv+KRRx4hKytrluetUqlkyZIlH7lP2dLSwvHjx3nrrbewWq2zXELgqjdqUlIS5eXlSKVSpqenOXr0KB6PB4lEQnh4OAqFIijXzu/3YzKZePnllzl79iwDAwO8+OKLlJaWUlhYSEREBGFhYchkMnG9IyMjVFVVIZFIyMnJYeXKlXO+ro8UHKempqipqaG7uxuTyURMTAxLliwRS2wCAoEAIyMjDA4OMj09zczMDEeOHMFsNiOVSlm3bl1QmW0Co87j8ZCbm8v27dtZvXo1+fn5otnntfD7/ajVatasWYPNZuPixYtMTU0xOTlJb28vLpdrTnp80dHRFBYW8sQTT4jl0SVLllBcXPyhJ2qHw0FsbCyhoaE0NTXR3d3NwMDAvJx4ZDIZy5Yto7Kykry8PFJTU9Hr9VgsFqxWKzKZ7IbNyWg00tHRAVwNkFqtlgceeGBWqXiuoNFoyM7O5tlnn8XtduNyuRgfHyciIgKlUolarSYlJQWTycTg4CCdnZ3IZDISEhLYsmULKSkpQXE6/6Rienqauro6Dhw4QENDA1arlZSUFMrKyli6dKnIIpRKpSgUCioqKoIeHCcmJmhra6OzsxOTyURISAipqamsXLlSbOc4nU6ampoYGBjAbreLFQudTjdvp1un08m+fftobm7GYrGQkJDA7t27ycrKIi0tjYyMDBISEkQDXqFcKeyT1xqyw9VTeXh4+EeuuCkUCsLDwwkNDSUuLo7CwkLRJByuHmIiIyOJiYmhs7OTvr4+MbFVKBQsW7bsY5V0bweJRCJyKcrKynjwwQfZvHkzaWlpN/3OhMrboUOHiIyMJDs7m9zc3Dlf111HJq/Xi9VqxWg0AhAXF8eyZcsoKysjMTFx1pHb6/XS2NjI6dOncblcOJ1Ozp49i9VqJSIigtWrV88L7VsqlZKZmcmWLVtYvXr1bX9Oq9WybNkyJicnyc7Oxmg0YrPZMBqNok/lx0VMTAwRERHk5uYyPj4u9j+joqI+9LWBQICcnBwGBgaYmZmhq6sLg8GA3W7/2Ov6MMhkMkpLS1Gr1eKJ94MPPmBsbAyTyTQrMPr9fpxOJx0dHbS3tyOVSgkLCyM+Pj5opI2IiAi0Wi0vvPCCSIJob28nKSmJiIgIIiIiiIuLo7W1lTNnzoifKTk5me3btxMVFbXIILwGU1NTvPfeexw8eBCz2YxcLic/P5/t27eTnp5OVVWV2L/X6XSsXr066CMKY2NjNDc3YzAYUCqVxMfHs2LFCj772c8SHR0NXC0f2u12xsfHsdvtaLVakfAyX6biLpeLY8eOYbPZ0Gq1FBcX88UvfpHs7OxZCbZAHBM4A16vF6fTeYOHquCd+lERGRlJYmIi2dnZyOVydu3axWc/+9lZSarf76e7u5uRkRGGhobw+XziNRa+22AFx/DwcFasWEFRURGrVq1Cq9Xe9L28Xi8dHR1cvHiRqqoq1qxZw9KlS8nIyJjzdd311Y6MjKSsrIyjR4/i9XqRSqXExsbe0vQ2EAjwxz/+USwxwNWLMV99R7iaxR05coQvfelLd/TzUVFRrFixgqeffprm5mZcLtcsFulcQCaTiRv23cBisXDs2DF++9vf0tnZiVQqJS8vLygnseshkUhQqVSsWLFC/PNjjz0GzO4t+nw+DAYDBw4coK+vD7jKsn3ooYfYs2cPS5YsCVoGL5FISEhIEP+8ZMkS8f8LOHz4ML/+9a8BCA8PJykpifvuuy8os1KfZLjdbiYmJsR7Pzw8nH/8x38kLi6O4eFh3njjDYxGIxs2bOAb3/jGvJy6bTYb09PTKJVKvv71r/PAAw9QVFREWFgYAwMD1NbW8uKLLzI5OSkmjEuXLiU3N3deZwsVCgU7d+5EJpORnZ3N5z//eSIjI28Izkajkbfffpu6ujomJyeJjIwkKSlpVkl1LhAbGyteq5CQELRa7azrIRDVvva1r9HQ0IBerwdgy5YtbN++nS984QtBPXXLZDIqKyuBGwlVAhwOB93d3fyP//E/GBgYIDc3l5/97GdzxgW5YU0f5UUSiYSYmBjxpPBhgc5sNjM5OQlcZVvGxsaSm5sb1CxOIpGgVquJjIwkKioKo9HImTNn0Gg0bNq06bavHR4e5vz587z++utieWOh3bt9Ph9Xrlzh8uXLvPHGGwwODqLRaCgqKmLTpk1Bu0FuhmuvxfUPjMfjwWAw8NZbb3Hw4EF6enqQSCQsX76c9evXs3HjxnllDF67VrfbzX/+539y5MgRhoeHSUlJ4dlnn2X9+vWo1eoF/47vNZhMJs6ePYvT6SQuLo7c3FwKCwuprq6murqayclJlEoliYmJ88YEXbp0KWq1Gq1Wy8aNG0lPTwfg1VdfpaGhgaamJiYmJvD5fMTFxVFZWcnjjz8+r0Qrk8nE2NgYFRUVKBQKtFoto6OjVFdXY7PZRALT4OAgAwMDNDY2MjY2Rnp6Ojt27CAxMTEo5DqFQkFCQsINp9Cenh7a2to4ePAgjY2NTE1NIZfLefTRR9m1axf33XffvHy3t3v+GhsbaWxsZP/+/RgMBsrLy/nUpz5FWlpa0AhCH/mcfqdZttVqZWRkhOHhYQASExPJzMwkMzMz6Bdco9GQmZlJcXExDQ0NTE5OihnRzeD3+3E4HOKIRV1dHR6Ph/DwcLGfOt8bqM/nw+Vy0dvby7lz57h48SKXLl1CLpeTk5PD/fffT1ZW1ryy8G4Fi8XC8PAwnZ2dHD9+XDx15+TksHbtWpYvX75gYxJms5n+/n4OHTpEd3c3MpmM8vJytmzZclPq/CKu9qHCw8NJSUkhIyOD0tJSlEol3d3d1NfX43A4SExMJC4uTiRmBRvC+JBAIJFIJHR3d3P06FGRIBgeHk5iYiI5OTk8+OCDrFu3LujzedfC6XQyMzNDWFgYDocDi8XC4OAgDQ0NzMzMiMGxt7dXnHWMjY0lPz+f+++/H41GE5SDg9C3hKuVHrfbjV6v5/z589TX13P06FEmJiZQq9WkpqaydetWysrKglKyvBO4XC7sdjujo6OcO3eOuro6uru7yc3NZe3atVRWVqLRaIJ23wV1R/B6vbS1tXHu3DlqamqQSCTs2rWLrVu3UlxcHMy3BiApKYk9e/aQl5fHd77zHeLj428bRFwuF+3t7bS3t6PX63G73QAkJyezbNkyVCrVvPUsBFitVoaGhvjXf/1XamtrGRwcBGDHjh1s376d5557bl7Xcyv4/X5aWlrYu3cvx44do6urC0DstezatUvsCS0EGhsb+fnPf87JkyeJiIigsLCQ733ve0HNPD/pyMzM5KWXXsJgMLB06VJKS0sZGhqioaGBy5cvI5FIyMrKIjMzc87LgLeDwDoG6Ojo4Ec/+hEnT57EbDYjk8lIS0vjscceY/PmzWzevHne1iUgEAiIPccPPviA/v7+D33Ntm3bePDBB9myZcu89L2FMupPfvITDh8+TE9PD3D1dLl27Vq+9KUv8cADDyxo0ij0l1955RXa2tpQKBQ888wzPProoyQmJoqBPlgI2ifv7++noaGB733ve/T09BAVFcVDDz3Epz71qaCPHFyL+Ph4IiIi+M1vfkN4eLh4QQUmq81mE9fb3NzMT3/6U6xW66w5IL1ej9Vq5Rvf+Aa7du2ioKAgqNmUx+PBZDKJg7AXL16kubkZh8OBVqtly5YtfOUrXyE/Pz9oa7gbmEwment7ef755xkaGsJkMgGQnp7OmjVrePzxx4OWDX8Y/H4///7v/86ZM2c4e/YsHo+HrVu3smfPHrKyshYJOLdBXFwcu3btwufzERYWRmhoKHq9nkAgIPaY+/v7GRgYwGq1LgjT1+l0Mjg4iNfrRaFQEB8fz2uvvUZmZuYdEdzmGjabjbfffptXXnllVt/zemg0Glwul5iAa7VaVCrVvNyPNpuNI0eO8Ic//IFjx47dMPPo8Xiw2+2YzWY0Gs28jL4IMJvNXLlyhXfeeYfW1lY6OzvFGVaFQsHevXsxGo0UFxdTVlZGenp60CqQQQmOBoOBpqYmsYQVGRlJVlYWu3fvJicnZ14b48J8m8AQs1qtojLK2NiYWGYdHx9nYGCAnp4evF7vLAKOy+XCaDRy/vx5NBoNbrd7ToOj3W4X1YXGxsYwGAzo9XouXLhAd3c3XV1dovJIREQEqampqFSqBcvqhOvR0tLC0NCQqDDT2dmJ3W4nPDycyspKCgsLKS8vn5dNyuFwiMlOb28vKSkpyGQyrly5QlVVFa2trczMzLB8+XJKS0spKiqa14f+k4iQkJBZhDG/309sbCzJyckkJCQwPj4ufvd6vZ7c3Nx5V6ARyCUC09PtdmMwGEhKSpr3tcBVhu/Q0BB9fX0i41QoZ2ZmZhIbG0t8fDxRUVFYrVYmJyc5deqUyKouLy8nLi4uqGuXSqWEhoYil8txOp2zVLl8Ph9DQ0McOXKEoaEhEhISiI2NJSkpiZSUFNGYIRjo6emho6ODY8eOcf78eaxWKwqFgry8PBwOhyizKcjddXR0UFJSIo7FzHXpfE5310AggNfrpbOzk6qqKt555x28Xi/5+flUVlby6U9/ekFu2GsxNTXFu+++S39/P1euXKGxsXHW3wuCBdciEAjg8/loamoSR1K2bds2Z4zb6elpent76ezs5OLFi3R3d9PT0yPKTQmQSCRIpVI0Gg0jIyPI5XIUCkXQlXH8fr94UhAk5Nra2viv//ovjh8/jtlsBv7CWNXpdDz11FOUlJSg0+mCujZhTePj40xMTDA8PMyBAwfYtGkTarWa//f//h+nT59mZmaG0NBQKisrKS0tXbA+yicZUqmU1NRUioqK6O3tZWpqiunpaQYGBmhpaSEtLQ2FQjGvz7hSqSQnJ4eamhpR9uzdd98lEAigUChITEycV56AMD4SGhoqDtkrFAri4uLYsmULK1asoKSkhNjYWFHRqa2tjVOnTuHxeCgvL6eioiKoiZtcLic1NZWysjKqq6uZnp7G6XTi9/vx+/20t7dz5coVtFqtKE+5YcMGNm/eTFJSkpiYz/V1raur4/jx47z55puoVCpx9jsjI4Ph4eFZB5jm5mbsdjurV6/m/vvvZ82aNZSWlhIWFjZn99+cunIIWdB3vvMdBgYGcDqdYil11apVpKWlicoMC3XquXjxIp/5zGcYHx+fZVkVCAQICwsTS4HXnm71ej1DQ0PU1tYSEhJCWloan/rUp/jmN785J320vXv38tprr3Hp0iW8Xq8oD3dtUIK/BEeZTCZKK1VUVPC9730vKMLoQtO+ra0Nt9uN1+ultbWVw4cP09raSn9//01nP0NCQggLC2P58uVs376dl156ac7XJkAgUH3jG9+gubmZwcFBsQwokUjEQXW4WkXYuXMnW7ZsYc2aNeJIykfAJ5XWOieuHP39/dTU1PDVr36VyclJ/H4/SqWSn/zkJ1RUVIjjM/MB4R79/e9/z6FDh/jzn/+Mx+Nh9erVVFRUiKMn81U+9/v91NfXc+nSJfR6PRkZGWJCERMTQ2hoqKg7HQgEmJ6e5g9/+AP/9m//htFoZMmSJfzxj38kPj4+qHuk3+/HZrPx7rvvcvnyZZE5C1eJdRMTE5hMJqRSqfgrLS2NwsJCdu7cybZt24iKiprTxPytt96iv7+fsLAwNmzYQGJiIrGxseK1EvZFo9GI0WhkZGSEl19+mYGBAdxuN1u3buWFF14gPz//bpOL4Lty2O12uru7mZiYwGazEQgEuHz5MjMzM7z33nsolUqUSiVRUVEkJSWRn58vMt2unU0LJgTh7vHxcVE5Q1DMEebdMjIyZjV7zWYzfX19dHd3Y7PZMJlM1NTU3KBi8VERExNDQUGBWBZQq9UsX74cpVI5KwsaGBhAr9fT3d3NlStXRK3G6upqiouL55wJ2tPTw969e2ltbcXtdos3pqB45PF4xHmpa+cs3W43fX1983aCEAQHhNIqIOpsXhu4vV4vDQ0NokSgMLheUFDAqlWr5mWtfw2Ii4tj+fLlfP7zn+dXv/qV6Mixf/9+wsLCiI6OJiYmZl7WIpgbVFRUoNVqSUlJ4Z133sFgMHD+/HmcTiebNm1i6dKl88J1kEqlZGVlodFosFqtaLVa1Go10dHRN1SaJBIJGo2GdevW8fvf/x6r1crAwABDQ0OEh4cHtR0hlUpRKpWsW7eO/Px8LBaL2HucmZlhfHyczs5OBgcHGR4eprW1lZGREZxOJwaDgcHBQTZu3Mh99903ZwFy1apVFBQUiGo54eHhN52KkMlkaLVaYmNjeeGFF0Qx/NOnTxMfH8/69evZtWvXx17PnJdVPR4P0dHR4lhEf3+/OAgOiB8qKyuLNWvWkJqaSmpqqqiKEOwMT61WU1JSgsPhwOVyoVQqWb9+PVlZWWRlZbFu3bobWKkej4fMzEzUarX4uoGBgVm1+o+DxMREysrKxD/HxMSwbt06IiIiZgWYK1eu0NnZSX19vSiQ3tHRwenTp1Gr1eh0ujktx0xOTnL06FHq6urw+/2EhISI1GlhI4qLiyMhIUGcsxQenrGxsXkJjlKpFLlcTnJyMpOTk1itVmw2GwqFgtDQUGQyGQqFQiz5W61WmpqacLvdooC1y+WitLR0QQhDn0SoVCpSUlLYtm0bH3zwATabDavVysWLF1m6dCmZmZnzFhwFCAEpPj6egYEBjEYjVquVo0eP4vf7MZvNKJVKUTYymKXW6OjoO64oyeVycnNziYuLQy6XMzExwejoKImJiUHv1YeEhIj73rWw2WxMTU3R2tpKe3s7nZ2dBAIBsXWh1+uZmZlBJpOh0+nIy8ubk2c9Ozv7jn5OLpcjl8vRaDTs3LmTkJAQ/H4/b7zxhqi3WlFR8bEVfea0rGq32xkcHOTy5cu0tLRQW1sr3py3Q1xcHN/61rfYs2dP0OfgBPsdofwml8tZtmzZh15EvV7P+vXrGR8fRyqVEh8fz6lTpxbMu+4//uM/OHr0KAcOHCAiIoLnnnuOp59+ek41BltaWvjZz37G22+/Lc6Vbd68GaVSSVJSErt37xY1GwXCU0tLCxcvXuS73/0ukZGRbN26lR/84AdztqZbYWxsjAsXLnD8+HGOHDlCUVER2dnZYoXC7XYzPDxMd3c3ra2tdHR00N/fT0REBFu3buWVV14hOjr6Th+mv+my6rX4xS9+weHDh/nTn/6E1+slIyOD8vJy3n777QUTVbBarVitVrq7u/nWt75FS0sLERERrFq1ih/84AfodLqg9+nvFk899RSnTp1iZGSEH/3oR1RWVlJUVLTQyxL5FlarlRdffJHTp0/T2toKQGpqKiUlJfzmN79BrVYvWHIpMJa/9rWvceHCBZKSknjuued48skn71QL+6Y3asi3v/3t273otn95wz8WEiIOkC5fvpwNGzawadMmVq9ezapVq9iwYQNpaWlERUWJA57Cxe/v7yc1NRW1Wh3UjElQ9BFKgTExMbc9bdlsNjo7O7lw4QLvvvsubrcbnU7Htm3b2Lp164LNyKWlpeF2u3n//ffx+/3k5+ezdOnSOQ3WGo2GkpIS/u7v/o4nn3ySxx57jI0bN1JeXk5RURGxsbGEh4fPKhedPHmSQ4cOUVtbi0ajITc3ly1btszZmm4FIXivXLmS3bt3s23bNtauXUtxcTGZmZmkpaWRm5tLaWkpWq0WiURCY2MjKpWK/Px8Hn300bshWP1rsD9PkPDtj/Iip9Mp9pyvr+ykpqYSEhJCW1sbJpNJrDCUlZWhVqsXRJJPqBZER0dTWloq+k3W19czNDSEQqEgPT39nhJ+ePfdd0W95NzcXDIyMkT1n2DB5/PR0dEhtiBu9l0JPIfQ0FCWLVtGXl4eEomEyclJbDYb4+PjDA4OotPpiI6OXpDRqJCQEJRKJUVFRTQ3NzM0NERrayuPP/74nY4X3fR5ntO7Q6Ash4eHExMTQ3JyMjExMYyNjYmjCENDQ4yOjpKXl0dDQ4PYv+rt7aW9vZ2UlJQbjvlzCUE66cMeDKHRf+rUKa5cuUJLSwtOpxO5XE58fDzl5eULqsWp0+nEHqVgFXatn91cIDw8/KZll1tBKPX29fXhcrlQq9XzNvsWGhpKVFTUhyZWRqMRt9vN9PQ0gKhvO59av58k+Hw+6uvr8Xq9hIeHU1paOut0HR8fz7Jly9iyZYvYA5+YmODIkSNoNBqxvD2fEAgkWq2WoqIiNm7ciEwmY3JykkuXLpGWlnZDKyOYENpNZrMZp9N5U66CxWIRR8j6+vro6uoiNTWVhISEOWVgwtX9YmRkRHyfsrKyD03yQ0JCyMzMRCaTYbVacTgcNDc3o9frOX36NBs2bBBHPeYbgnC5cEAQWK0ft+0V1NRJKpWSmJhIYmLirP8vZHLvvPMO+/fv59SpU1itVpqbm0lKSvpQ7dP5gDAv9cMf/pC2tjaRwBMXFydSm++10sxCwu/3izTr/v5+JBIJKSkpN3z3Cwm/309HRwcffPABhw8fBq6efFJSUhbFAG4CwdnkN7/5DQ6Hg+TkZEpKSm7YqAsLC3nhhRfYu3cv09PTjIyM8OMf/5iCggLi4uLmda75WghjFDt27BArKq+99proU7hixYqglwJ9Ph9ut1v0bx0dHRV1pq+FXq/HZrPh9/u5fPkyarUar9fLtm3b5tzI3GazUVVVxdtvv43FYkGn091xvy81NZXPfe5zREdH88Ybb9DX10dHRwednZ3k5OQsWJtJ+K6Li4tFwtDHxYLUFYTy6xNPPEFkZCQ6nY7XX3+dgYGBOflQHxfT09NUVVXxs5/9jNraWhwOByEhIWRkZPDSSy+xbt06MjIyFgkc18DtdvOTn/yE8+fPYzAYAFi5ciXLli1b4JVdhZC5f+973+Py5cuiZu4zzzxzTyRj9yL0ej1vv/02Bw8eJDo6+paVEmGe8LHHHuP06dNiibWtrY2UlBRKS0vneeWzoVQqKSgo4Omnn+bIkSN0dnYyMTFBZWUlZWVlQSEP+Xw+9Ho9b7zxBmfPnuXy5cuzZgmvx7U2VYODg4yNjXHu3DlRaH2ugmMgEODEiRMcPnyY2tpavvvd74pejXcKiUTC+vXrRX7BvbBn+/1+LBYL7733HufOnZuTf3PBiu5CpFer1eIXc60s1UdFe3s7vb29tLa2otPpRI+wm8Hv9+PxeOjq6mJqaoqpqSl6e3uxWq10dnbS3t6Oy+UiPj6ejIwMHn74YUpLS0lMTJyzwCgQg4T5yTuB1+vl8OHDnDx5kkAgII5TfNRebSAQEMvdgk+nMKh8J32ZgYEBLl68SG1tLWNjY6hUKnbv3s19990X9L7J7SBoXHZ2dtLR0UFdXR3Nzc04nU7S0tJ45JFHKC4unldR6k8ShJOjMEva0NDAH//4R9LS0oiJiSEuLg6ZTEZoaCihoaHs2LEDs9ks3kfC6XyhgyMgGl9brVacTid2u52RkZE5G8e6Hg6Hg1/96ldUV1czPj7OkiVLSEtLQyqV4vF4kEqlolH52NgYcDXJiImJIT4+XnQvio+Pn/P2zeDgIBMTEzidTtH78m5aCoFAgL6+PkZGRkQBkLnA6Ogofr9f7F0KIgp3AqFUPDU1hcvluhty3S2x4B3pawOiQNH9OOjs7OTkyZO88847Igv1ZvNNNpsNp9OJ1Wrl/PnzdHV10dPTw/nz5/H7/bjdbhwOBxqNhvz8fNasWcMTTzwxpyWOQCBAf38/VqsVqVRKcnLyhwZdj8eD0Wjk4MGDomFvbGwsOp3uI2fAws0uqN6rVCqSk5OJjIy8ITgKma/P58PhcOD1emlqauLdd9+ls7MTiURCZmYmTzzxBCtWrJhTctW198rtbvxAIIDNZhO9/06dOsWZM2c4dOgQfr+fpKQkCgsL+cIXvkBmZmbQBYw/qZDJZGg0GlQqFRMTE7S0tLBv3z6WLVtGRkYGS5YsQalUolKp0Gq1FBQUkJKSglqtxmg0cvbs2bv2Kw0GhMDY1NTEzMwMbrdb5BTMtU8rXE1ep6en2bt3L6Ojo8TExFBZWUYkZ58AACAASURBVMmaNWsICQnBZrPh9Xo5dOgQVquVsbExJBIJUVFRFBUVkZ+fLxKKEhMT5zw4OhwOfD4ffr+f5uZmKioqSE1NvaPvyu/343K5qK2tpaurSxR7l8vlH7s1IRCSEhMT0Wg0hIWFERYWJpL+brY3BgIB7HY7RqOR5uZmTCYToaGhc1LZW/DgODk5KarWJycnk5SU9LH+PafTidlsZnx8nMjISDo6Oqivr7/h59588036+/sZHR2ltbV1FplFpVIRHR3NsmXLeOCBB9i6dSurV68OCmGjra2N+vp6JiYmKCsrIyIi4pY3mcvlYmxsjL1793LkyBEGBwcJDQ1l165drF69+iP394TgePjwYWpqatizZ4/I+LsWgkyb3W5neHiYP//5zwwMDNDV1UVTUxMA69atY8OGDRQVFc25R6KQ0Pj9fuLj42/5c06nk71793LixAmqq6sxmUx4PB5CQkL41Kc+xZ49e9i4ceNt/41FXH0en3vuOdEurbm5mX379rFv3z7gavVHp9OJDvMOh4PW1lb0er242S9Uv/Fa1NTU8P777/Pzn/9cNBpQqVR3w2a8K3R1dXHmzBmGhoZwu90sW7aML3/5y6hUKtFU4ODBg/T29opuGBqNhvXr1/P973+ftLQ0cWOf6z1HIpGwZ88e7HY7HR0dHDx4kMnJSSorK/nOd77zoa83GAw0Njby8ssvMzY2RkhICDqdTgzqHwfHjh3j2LFj1NbWkp6eTkpKCpmZmezYsYMVK1bc9PBgt9s5dOgQhw4d4vXXX0cul7NmzRpefPHFj+0Us2DBMRAI0NjYyKVLl2hsbCQkJISEhISPrcWZn5/PwMAAKpUKvV7P73//e6qqqsT3hKs3iF6vFwf6PR6PaKCakpJCZWWlqKgRGxsrShjNNSQSCeXl5bS1tVFTU8O//Mu/kJ6eLo7CCAgEAlgsFmpra2lpaeHChQtMTk6iVqtJSkpi+/btH0uyy+fzidY6Pp+PiYkJjh8/zuDgoFgWHRoaor29nWPHjomGrYFAAKlUSlhYGMuWLWP37t2Ul5eTl5cnSmXNFdxuNz/+8Y/p7e3Fbrezbds20tLSCAsLw2KxYDabMZvNTE9P09XVxZUrV/4/e2ce3WZ15v+PJVneJFteJVve4t2OY8dOHC9xEhJnhTANCcNAy7R0mNJtOp0zC1MOv2lPp3Ta6ToMDJ3SUmC6QQmUBrLS7Kvjfd/3RbYk27ItybbW3x8579s4CSHElhKoPufkQGLZ77X0vve597nP8/0yPDzM1NQUarWa3NxcKioqKC8vJyEh4a6YtO92BD/Hxx9/nOLiYqqqqsTiHKfTiZ+fH0ajUfRsdTgcYvAB2Lx5M5s2bfLaeIVMkIDRaOT111/n/Pnz9PX1idXmeXl5rF+/3mMWdHa7nbm5OVH+cWRkhB/+8If09vaKCzy9Xs/4+DjBwcHcf//97Nixg5UrVxIbG+vxFpOEhAQ2b96Mw+Hg1VdfpaenB5PJxMTEBH/7t3+LWq0WF8eCycDZs2dpaGhgZGQEnU7H+Pg4/v7+JCYm8uMf/5jCwsIlZ9QeeeQR7rnnHkZHR7l48SJGoxGdTiday2k0mkULWrfbzdzcHHV1dbS3t6NUKnniiSfYsGEDBQUFS55/vB4cZ2dnxfRYfX09XV1dGAwG0bljqSIAGo2G1NRUsrKyaG9vZ2BggO7ubgBRjFir1RIQECB+mILCS1xcnHjjpKSkeOW8LCEhAa1Wi1Kp5OLFi/T09IjydgJut5vp6Wlqa2vp6OhgcHCQoKAgtFotGzZsICsra0kar35+fkRFRZGZmYlarUalUtHf3y+mncxmMzqdjp6eHpqbm1EqlahUKhITE1GpVEilUqRSKTt27CAjI2PZd2RCL6zgIyhoPiYnJxMQEMDMzAwmk0kMjp2dnTidTiQSCVlZWaI7yLZt20hPT/e1bXwIpFIpK1euJCwsjIiICHp7e5mYmGB2dlaU6pubm8NgMGC32/H390ehUKDVaiktLfV4QZbQoC5M2DqdTvya0WgUdYDn5+cJDAwkLS2N9evXs3HjRo9VKIeEhKBWq9FoNBiNRmZmZjhx4gQdHR2iDm1UVBRpaWnExsaKPo5qtdor7WEhISFkZGRgt9vp7OykpaWF8fFxDh8+TFJSEhqNBn9/f0JDQ7FYLBgMBk6fPk1tba24GIqIiCAlJYWCggK2bNkiahkvhbS0NJKTk7FYLEilUoaGhsQF7vT0tHikZLVasdvtLCwssLCwIKofFRYWsn37dvLy8palyGpZFXJuhdraWmw2G/7+/nz729+mrq6O8fFxSkpK+MEPfkBhYeGSrzEwMMDRo0d54YUXGBoaEnssXS4XSUlJPPbYYyiVykXnVtu2bSMnJ2fJ174dqqqqOHHiBC+//DI6nW7R6vfq3a6ARCJhxYoV7Nq1i3/7t38jMjJyyTem4Ao+MjJCf38/lZWV2O12UlJSaG1tJSIigujoaJqbm9m1axd5eXniOYWnq3ZdLhdWq5WHHnqIpqYmRkZGFn3d7XaLv7/w38zMTFatWsUjjzzC+vXrCQ8PX84V+Uc1si7peRYkxFpbW0UXGbiSRjx16hRmsxmlUklCQgJf+tKXuPfee9FqtR6VEZyZmaGlpYVXXnmFqqoq0WXn6ufB7XYTFhZGYmIi//Iv/0JxcbHHxdGnp6f5x3/8R86cOcPg4KB4bJOUlERBQQH3338/a9euJTU19Y4JiTidTnp6evjJT37CyZMnaWpqWjTfxMbGYjabsVqtYiUtXFkwVVRU8KlPfYq9e/feqgrNbY+xra2NsbEx9Ho9PT099Pb2MjY2hk6nY2FhgXXr1lFWVsbnP//5273MDZ9nrwfH5557jnPnznHp0iWmpqZEfdPPfOYzfOlLX1oW+TOHw4HVamVmZuY6b0ahyODaBzY4OPiO9botLCxgNptpa2vj1KlTDA0NAVeKiwYGBhgYGCAiIoLCwkLy8vKoqKggLi6OyMhIYmNjl23ycTgc4p/5+Xncbjf+/v7YbDZxd7iwsEBISAhyuRyZTOZVcfHu7m4OHTrE8ePHaW5uFqudIyIiiIuLIz09nZycHJKSkkTzWKERfZkD+J9lcIQ/9e0J3onwpzSisEiRyWSEhYURHBzs8RSh0WjkzJkzPPXUUwwODorVp4ISliAfuG7dOh544AGSkpIICgry+LPucrmYmJgQi9aEeVbwUQwJCRENpO9kFsNut4tayDU1NVRWVtLQ0EBVVRUymUyspI+IiKC4uJgVK1aQmppKRUUFGo2G8PBwj49f0EF2Op3Y7XbRTUk42hGygEs4Y/S8K8etIMi1CcLUQnpuw4YNy1bZKKi2L/VA1lsEBAQgl8vJzs5GIpGI6i2C8bFer0ehUJCcnCzaxoSGhiKXy5c1OF2tHHQnXN1vhmCZs2HDBqKioigrK0MulxMQECBKDqrVauLj48V7zNeHuvwI55B3C4GBgWJbTnt7O/39/VitVlJSUoiPjxefmdTUVK/u0iQSySKnmrsVf39/YmJiRKm/mJgY8vLyKC8vF18jlUoJCQkhNTWVmJgYsbVtOVKpt8KdMiW/I2nVQ4cO8dOf/hSZTCZO9t/5znfuqHitDx8fgj/bnePdhtBaMDMzQ1VVFX/84x8xGo3s2LGDNWvWiK0ld9pk3cddzd2RVhWKK4Qc9tXCtj58fETwBce7EKH/1u12I5VKRVNhHz4+gLsjOPrw8THgozrj+p5nHz6u54bPsy/X4MOHDx8+fFyDLzj68OHDhw8f1+ALjj58+PDhw8c1+IKjDx8+fPjwcQ2+4OjDhw8fPnxcgy84+vDhw4cPH9fgMYUcs9nMxMQEnZ2dzM7OLjIVFeTSkpOTRW84b2G1Wunt7eXUqVNYrVZkMhkajQatVktsbOyyyNf58OHjisbx3Nwc/v7+zM7OEhMTs2RLumsZGRnhzTffpKio6KbqNyqV6o4ab/v46LGswVEwwJ2enmZsbIz+/n7OnTuH0WhcZGVjsVgwmUwUFBQglUqJiYnxmqzT9PQ0lZWVvPrqq6IxZmZmJtnZ2eTk5BAeHr7cItXLhqB7KjgR2Gw2Ud/yWvz9/QkJCSE8PPxjqQ7idDpFpX7h73a7fZFAskBAQIDYFA5XpL0Ejd0P4zbu44MRBD4WFhbo7OzEZDIREhJCb28vKSkp2O121Gr1skkfjo+P86tf/Qqr1So6yAsIgiNOpxO1Wo3D4RDlBoODgz0iS+Z2u0XHCOH+vFrbWS6XExQURFhYGDKZzHfv3cUsawQwGAy89957/PSnP6W/v5+JiYlFO8arESyr5ubmsNlsfOITn1jOodwQm81Gd3c3//mf/8nAwIAYWNra2jh06BARERGcPHmS//f//h8rVqzw+Hg+LIODg4yMjDA2Nsbvfvc7mpqa6OjoECcZQfjZ7XaTlJTEQw89xJNPPrks9i13E06nE51Ox4svvkhHRwdwRYd2cHBQNM6+mvz8fGJiYkTtXpVKRUJCAp/5zGeIiYnxik3QnwtGo5Hh4WEqKytpbW1lbm6OiIgIXnnlFSwWC5GRkfzyl78kNzeXqKioJV/PZrMxNjbGCy+8gEajWZSFstvtopvDzMwMk5OTrFmzhj179rBr1y4KCgqWfP0bjaejo4Oamhqef/55ent7mZ6eBq48n1lZWWzevJmvfOUraLXaj4z+858jyxYcZ2dn6ejo4Fe/+hU6nQ6n04lSqRTdnAW/waioKPz9/XE4HLz00ksYDAbRhcLT2O12zGYzw8PDpKSkkJiYSHx8PI2NjfT394u7ypGREaKjo70qvr2wsMDBgwcZGhpidnYWgC984QvMzMxQXV1Nd3c33d3dYnDU6/XXWVtdbd30cUWv19PR0cHTTz/N0NAQfn5+ogtHRkYGiYmJ132PUqnE399fdEaor6/nvffe48iRI3zrW99izZo1vklqmQgPDyc4OBi1Wk1FRQUulwuZTEZmZiajo6Po9Xq+973v8dRTT7Fhw4YlXy8tLY1nn32WiIgIgoODFxnuut1uMbsiOPU88cQTvPTSS1RWVvL2228v+/MyOjrKwYMH+fWvf83Q0JDoViIwPDzMu+++S0dHB5s3b6akpIStW7cu6xgELl++zOXLl6mqqsJgMOB0OgkICKCwsHDRglChUBAZGUleXh7p6eleXyy6XC6mpqZ4/fXXRe/d9vZ27HY7EomE8PBw5HI5DocDo9HIvn37WL16Nfn5+Us2WL4Zy7pzDAoKIikpCbVaLU7UQq5fCI6RkZE4nU4mJyeRyWTMz89jtVqXcxjvy/T0tGgjk52dzerVq8nKykKlUuFwOOjo6GBkZIT29nYiIyPJzs72yriMRiP9/f0cO3aMwcFBzGazOOkLJse9vb3odDoMBgNTU1OoVCqCg4NRKpXMzs5el2KVyWSiEfGHxe12097ejsViITAwkPHxcdGK6OqAfCsEBgYSGRlJRkYGAQEBt51Kc7vdVFdX09PTQ0tLC1VVVWRnZ4uOCx8mFR4SEkJ7ezvnz5+nuroalUrlkV3EnyNyuRy5XI5SqVz07w6Hg6qqKkZHRxkbG2N+fn5ZrhcWFiY6+tzsXjcajbS0tDA7OytmHjyxmHS5XExOTtLb2yv+jldfw2KxYLFYMBqNYgp29erVqFSqZT/K6e7u5uTJk1y8eJHJyUlsNhuBgYEYDIZFQUUIjjqdjtHRUZKTk0lNTfWaCcTCwgLV1dVUV1fT39+Pv78/HR0dKBQKYmJixMWFRCLB7XbT0NDA7OwsU1NTrFu3DoVC4ZEU+bJ9GkqlknXr1rFu3boPfO3o6Cg1NTVe3+UMDAzQ29sLwK5du1i/fj3Z2dmUlJRgtVoZGxtjbGyMw4cPI5FIvBYc6+rq2L9/P7/4xS8WCbKfOXNm0ev8/PxEofbk5GRiYmJQqVRUV1czMTGBzWYTd5DBwcFkZGTclqC7w+HgxRdfpKuri8TERN566y38/f1RKpW0t7fzAXq8i0hISOCee+7hm9/8JhqN5rbtjhwOB9/4xjdoampCr9cTGxvL008/zaZNmz50es5kMtHY2MimTZs4ePAgbrfbFxw9iNvtJjo6moGBAf7whz+wa9euZbOn8/f3/8DP3+VyUVNTw9e//nUsFgs5OTkUFxd7ZP4JDw8nKiqK6OjoRRkx4bkVmJ+f59y5c4yMjFBaWkppaSlhYWHLOpbOzk7OnDmD0WhcdN3Kykrx78ICQRjfihUreOihh3jqqac8amJ8NbOzszz33HNigWRkZCRlZWWUlpaybds2IiMjkUqluN1uFhYW+OpXv8qpU6eYn5/nlVdeITs72yP2YHek6mRoaIgDBw6IO50PM9kuhfn5eXE1l5qaikajwc/PD61WS0lJCUajkf3792OxWLy2m4Urab7XXnsN4DpHe+H/XS4XGzdupKCggMzMTHJzc4mJiSEsLIwnn3ySyspKZmZmrvu+D8vMzAy//e1vOXHiBF1dXfj7+2O1WvHz80Ov14uvEwp+1Go1ZrOZkZGRG/48k8lEdXU1JpOJiIiI2w6Ofn5+5OXlsWPHDjIyMsjLyyMiIuK2UkBDQ0O0tLQAEBERsWwTtY/FjI+PMzk5iU6n4+WXX2ZwcJDk5GQ+8YlPoNVqPX59h8OBwWDgySef5PLlywwODvLwww+zZ88eNm/e7JHgqFKpSE1NJT8/n+HhYdLS0lixYgWFhYVkZGQgk8mwWq185zvfwWg0MjY2xo9+9COeffbZZQ+OycnJrFmzhqNHjxIQEIBGo6GoqIiUlBT8/f2Zm5vj8OHDFBUVIZfLeffddxkaGqK1tZXW1lYKCwu9snuUSqXExsZSVFQkzm3wp+KlqxcVbrebb3/72xw4cIDnnnuOwcFBtFrtxyc4zs7O0tvbi8vlIjQ01GumoFqtlszMTDIzM1EqlWIaQyqVim7ScGWHOTo66pUx1dfXMzw8jJ+fHwqFApVKJd4Q0dHRaLVakpOTcblcZGRkkJCQgFqtRiKRMDg4yKVLl2hvb8dkMomrwIceeoj169ff1s7Rz89PXI2bTCZmZmaQyWTk5+ezdu1a4Ep62s/Pj7i4OCIiIqirq+P3v//9DStnVSoVa9asITw8fElnGRKJhK1btxIREYFGo7ntlgCz2UxlZSWHDx8mNDSUsrIyCgsLb3tcPv6Ey+XCZrMxOztLbW0tTU1N6HQ6JicnqampQavVsnbtWnJycjx+xqvT6ejr6+PAgQNUVlYik8l45JFHuP/++8nPz/fYgkgikZCVlcWDDz5IWloaarWaiIgIYmJimJ6eFhfo8/PzOBwO/Pz8FmV9biVgWywWzGYzarX6pq9LSUlh/fr16HQ6UlJSSElJoaysjKioKCQSCfPz88zNzaFQKMSFtdPppK+vj0OHDhEWFiae5XqymyAoKIjdu3eTnJyMWq3+wAJCtVpNeHi4eNQipIGXG68HR5vNhslkEgNCZGQk8fHxXrl2cnIyc3NzlJaWLjJWFh5qYXIfGhpibGzM4+Nxu900NzdjNptJSEgAID09naioKPz8/MjOzmbNmjXXFS7Y7Xaqq6s5ceIE3/nOd/Dz8xMDfFBQEI8//jjbtm27rTHJZDK0Wi35+fkoFAp0Oh0zMzPs3LmTxx9/HLjy/tjtdlasWIFEIkEul3Pw4MFFwdHf35+AgACSk5PZvn07arV6SYfnQnC8XRwOB3Nzc/T19XHixAmOHj1KVlYWmzZtYs2aNbf9c/8ccbvduFwusUXB6XRis9mYn59nenqakZERXnvtNc6fP8/4+Dh2u52wsDBKSkrYtm0bqampHm0vmpubo62tjdOnT/O9732PsLAwtm7dyt/93d+Rl5fn8Tat7Oxs0tLS2Llzp/i+GI1G6uvrMZlMzM3NYTabcTgcyGQycUExNzd3S0HIZDIxNDREdHT0Td/HtLQ04Mp5a1lZGVlZWeTn54tfX1hYwGq10tLSwtjYmOiFOTAwwIEDBygoKBADvCeDY3Bw8IfqVhDuPYfDQUNDA5s2bfLIuLweHM+dO8fZs2fp7u4mJSWF4uLiZalauxXkcjl5eXn87Gc/E/vb3G43IyMjXLx4UTzji46O9kr7g5+fH5/85CfZuHEjg4ODAGRkZIjFS9eeU8CVB7+xsZFvfvObNDQ0iOcF8fHxZGRk8NnPflZMS9wOQUFBbN++na1bt4rnl3AlOAmLidDQUPR6PRcuXODMmTPU1dUtKtQJDAwkNzeXXbt2sWbNGsrLyz1aVXYr1NfX85vf/Iaf//znmM1mkpKSeOutt7yS3vu4MT09zdTUFMPDw8CVwo9Tp04xNDREX1+fWK0ukUiIjY2lvLycz372s2RkZKDVaj0aGG02Gy+//DK/+tWvqKurQ6vV8pOf/ISioiJiYmK8UucglUpxuVz09/fz8ssvc+HCBTo6OsTFhNB/CVcWFq2trfzmN7/BaDSyZ8+em/5sl8vFwMAAZ8+eZe3atTd9L+Pi4oiNjaWsrOyGxs8BAQHcf//9OJ1OBgcHxWOTubk5xsfHcTgcYrHO3cThw4c5ffo0U1NTbNq0SdxYLDdeC442m01cUV66dEncCXi7dHhhYYHR0VEuXbpEb28vAwMDTExM0NzcjMlkAiAmJgalUonZbCYkJMSjD5SQPhXaRhQKhbiybWhoYG5uDpfLRW9vL42NjfT19TE5OUlra6uYSgWIj4+ntLSU9evXLzllJOxEr8XpdNLV1UV1dTUtLS2cOnUKvV7P7OwsAQEBrFq1SswEPPTQQ2i1WsLDw1EqlV4vvuru7mZ4eJihoSHOnDlDf38/AwMDBAQEsG3bNjZv3kxsbKxHqtw+rrjdbiYnJ9m/fz+XLl1iYGAAuJKq1uv1zM/PY7PZCAsLY82aNaxevZq0tDRyc3NZsWIFSqXSo4Hx0qVLvP3227z33ntYrVaKi4v553/+Z4qKiggPD/fqPWi326msrKSpqWlRT/WNcLvdnDx5EqlUSk5Ozk0rRYXezZaWlkXiAu+HUGV+s6/L5fJFc7DNZmN6eppz584RFxd3w/Yob9Pf38/4+DgGg4Ff/vKX9Pf3ExsbS2lp6bKrLgl4JTi63W7MZjP19fVcvnyZ4eFh1Go1ZWVlJCQkeE3Bxel0YjKZqKmp4ejRo7S3t9PV1YXFYsFut4uBxm63YzAYqK6uZuXKlSiVSgICAjz2cAUFBS0qVLHb7RiNRs6fP4/JZMLlctHe3k5lZSU9PT3XnU2o1WqysrIoLCwkPj7eI+O02+3MzMxw9uxZLl68KLZTwJWdZFJSEps2bUKj0ZCYmEhFRYXHP9fu7m7MZjMymQy5XL6oLai5uZn+/n56eno4cuSIuPCJjo4mISGB3Nxcr6kyfVwQdi2XL1/m1KlTDA8Pi5Oq0+kkKSmJqKgoYmJi2LhxI8XFxSQlJXls8oI/KdJ0dnZy+vRp3n33XSwWi1iFvnv3bo9d+2a4XC7Gx8eZnp5mbm7uuq/LZDJCQkIICAjAYrEwNDREXV0d58+fJzo6elFNxNW43W4cDseSW2GcTicLCwuicMbVxXZCylI4F/UWwmdpNpvFudjtdqPX62lsbGRgYEA8Sw4ICKCgoICMjAxUKpVHxuOV4LiwsMDQ0BAvvPACfX19REVFUVFRwd69e71WLgxXdFXb2tr4/ve/T1NT0/veYHV1dbS1tXHgwAG++93vUlhYKFZ4eQODwcBrr73G97//fbHH8OqSa/hTJapUKmXfvn3s27ePzZs3e2xMk5OTtLS08E//9E/Mzc2JaSG4cvC/d+9e/uVf/sWrWYBvfvObXLp0iaioKGJjY+np6aGxsfGm32MwGGhoaECj0XDPPfd4Z6AfE2w2G++88w59fX3Y7XYCAwNJSUnB6XQyMzPD008/TUlJCenp6V4d0/j4OE888QRtbW3Mz8/zjW98g927dy/peGGpSCQSoqKiiIqKYnx8fFE7BVzptS0uLiYuLo6Ghga6urqoqqqis7NTLBq8UTrT398fjUbDqlWrlrT4NJvNDA4O8q1vfYuLFy+KKXLhGgqFgp07d3pV91r4LCsrK8XguLCwwC9+8Qt6enowGo0sLCywd+9etm/fzoMPPohKpfLYpsWjwdHpdNLW1sbBgwc5f/48lZWVpKamsn79eh5++GGvKzFcvnyZ48eP09zcfJ2s3erVq0Vh4vr6eiYnJxkbG+Nf//VfxXPRr3zlKx5PzfzjP/4jhw8fFgULrl5BXS0PJ/yby+Xi9ddfR6FQoNFoPNKbabfbee+993jxxRevC4xw5aaemJhgZmYGlUrltUVESkoK3d3d1NfX09rauih1tWrVKmJjYwEoLS3FZrOJLRx9fX3813/9F7/+9a/FCd2bk8BHlcDAQL74xS+yb98+pqammJ6eJjk5GZvNxuDgII2NjaSmpno1OLa3t/PVr36V5uZmMjMz2blzJ4899tgdb88JDAzk4YcfZtWqVTQ0NPDGG2+QmJhIenq62IYUFxdHSEgIQ0ND/M///A/19fX09vby7LPP8sgjj3Dvvfdel/aXSqUolUrUavVtz0V2u53z58+zf/9+3nvvvUW618LXTSYTX/3qVwkJCSEiIoLy8nLS0tJIT0+npKTEI8+4xWKhtraWJ598ctEcNzU1hc1mE+ed6upqLBYL4+Pj7N27F61Wu+xtMOCh4GgwGJiYmGBsbIyzZ89y/vx52tvbMZvNYllzaGgoNpvtfc+3PIHQBhAVFYVOp8Pf35+wsDASEhLYvHmzGFhyc3Pp6OgQU8A1NTU4nU62bdtGYmKiR3a7DoeD9vZ2mpubaW9vXxQEBa59GITXCIHpRumb5cDtdosVctcGRriyq2xsbOTtt99GpVIRFhZGSkoKkZGRBAcHe2wRVFxcjEKhYNWqVdd97WrJwpycHJxOJ3q9nry8POrq6mhtbaWhoYEDBw4wNTXFzp07SUxM9Nq9eLfhcrlEkez360X18/MTn92FP2CBRQAAIABJREFUhQXm5uaIiorCZrOJusQDAwNotVqvOWDMzs7S0NCA2WxGq9VSUVFBTEzMHRfbF2oJhLYVPz8/oqOjRTlNhUIh1hcolUruu+8+UT2sqamJrKwsUlJSyMvLu+5nh4aGLun4ZHh4mObmZqqrq5menhZTvILMovBz5+fnMZlMjI6OYrfbaW9vJysrC4fDQW5uLkqlclkL7YSugcnJSXHuk0qlJCUlYTQaxSOT+fl5RkZGqKqqQiqVir2k+fn5yyrm7pHg2NHRQX19PdXV1Rw8eFCUNwPEQ/mJiQlCQ0MJDw8nJCTEKy4YQprl5MmTnD9/HoVCQUZGBlu3bmXnzp3i151OJxcuXOC//uu/0Ov1ou7qqVOn2L1797IHR7fbLTbkjo2NLUqfAmJlrUwmEz98YSUl9EpJpVKPTuwymYzAwMBFGqVC1d3Y2BgGg4HBwUEUCgWxsbHs27ePgoIC4uLi0Gg0HhnTvffey7333vuhv+/s2bMcP36c7u5uXn/9ddra2lAoFF5P899NzM7OMj8/j9Pp/EChhsDAQAIDA8XVukwmIzY2lqmpKdrb20UZSW/gdruZn5/H7Xaj0WhYu3btDYtfJBKJ+Ofa58tTCM3tQoP7+xEREcGjjz5KZmYmZrOZ/fv3U1VVJaZPrx1rREQEGRkZt/07dHR00NraSldXF3K5nNDQUFQqFcnJySgUCvHnms1mUbJSmM/r6urQ6XQ8/vjjpKSkoFarl23ekUqlBAcHo9VqxTkmMDCQLVu20NTUJKZ+Bc3crq4umpubSU9PZ/Xq1SQmJhIeHr5su1q/D1Cn+dDSNW63mwcffJC6ujpGR0eva2719/dfZBm0e/dudu7cyd69e2/zV/hwCIUlk5OT4gMeEBAgjkvAZrMxNTXF5z73Oerr65mamuL+++/na1/72g1Xc0thdHSUlpYWvvKVrzAyMiJqqwqfjVwuZ8eOHWzbto01a9aQm5vLM888w+nTp7l8+TJ+fn4888wzfO1rX/PYitlgMNDT08N3v/td0TpramqKrq4ucXISDu8lEgn+/v6sXbuWnTt38uSTT97xlfzVOJ1O5ufnGRwc5J/+6Z+oqanBarVy6tQp0tPTb6VB/aOq7n7D59nhcPDggw+Sk5PD5s2bb6tH1maz8cUvfhG1Wk1OTg6PPvrokgd7K4yPj3P48GGeeuopJicnUSgU7Nq167oJW6vVsm7dOjQaDUlJSWLK/W7CYrEwMjLCJz7xCbKzs9m2bRtf+MIXrguCwhHL7T5TNptNLI6cmJigvLxc7K++lpmZGYxGI5cuXeJXv/oVHR0dTE1NkZSUxLZt29i5cyf33Xffsiw2hMX2tbUgMplM7MG8GqfTycGDBzl+/Ditra1ERUXxH//xHzfMJH0ANxz8sm/X/Pz8KCkpQSqV0tnZSXl5uZgCEMq/p6ammJqaYnJyktOnT2MwGJDL5ZSWlnq8p0YmkxEWFkZQUBBSqRS5XH7DD1ZIuSYmJortEw6HwyNSd2FhYaSlpfHoo49iMBiuS4/KZDJ2797NihUrxLRWWVkZJpNJDI59fX1cuHCB8vLyZR+fMMb09HS++MUvimed8/Pz9PT0MDc3x/z8PKdOnQKuHKLX19fT0dFBTEwMtbW1pKSkiNV5dxphhZqQkMBnP/tZ4uPj+fnPf87Zs2eRSqWsXr36Tg/Rq7jdbqanp5mZmRErBT/MZDczMyOeOXpLckwgLCyM8vJyvvvd79Lf38/IyIgo9iE4A8GfWiscDgc2mw25XM7OnTspKCgQ0+93msDAQNRqNRqNhomJCaqqqvj85z9/w+OUpQQjf39/UlNTUSqVzM/PExcXh0qluuGzKchEBgQEEB4eTmdnJ1VVVVy4cIHTp08zMTFBeno68fHxS866CNmxW3VDcrvdlJSUEB4eTkNDAy+88AKHDh3CbDZTWlq6pLGAh9KqJSUlBAUFERMTw8MPP0xmZiYSiYTIyEiam5sZHR0VS5e7urrQ6/VkZ2eTnZ3t8eB4dXryVl63FD3QWyUkJISEhAT+4i/+gqmpqeuKhWQyGZs2bVo06ajValFJJyIiApPJRFtbG+vXr/dIykgulxMZGcmOHTsW/fvIyIgoQyWsZGdnZxkdHWVqaoqOjg7Onj2LXC5Hq9XeFcEREOX6KioqmJub42c/+xmXL19mxYoVf3bBEa40fguOEbeKsEAaHh7m0qVLDA8PU1BQ4LHS+hsRGBhIWloaaWlpDA4O0traCiAaDQu7IZ1OR0NDg3hMYjKZkEgkYgHZtS4idwKpVEpISAgqlYqenh7RD/NafdGlIiiT3cpc6+/vL74/iYmJDA4OolaraWtrY3h4GL1ez3333UdISIjXjyT8/PxISUkRq4JfeeUVGhoaUKlUlJSULHke9Ehw3LBhww1Vb/72b/8WuNJSodPp2Lp1K2NjY7hcLkZGRt7XGPnPAZlM9qHStYcOHeLkyZP4+fnxl3/5lx471/sgrlaYeeaZZwCYmJggLi6O//3f/6WpqYl//dd/5emnn2bnzp13ndrG1cLjp06d+rPUWXW73fT39xMcHMz4+PgtfY/T6RQ1VN99913+53/+h3Xr1lFRUXHb0oVLJTEx8ZYa1gcGBqipqeHBBx/EZDKxY8cOrx3r3Cpms5mZmRkaGxvJzs726oLj/QgICCA9PZ3U1FTcbjdvvvkmJ0+e5Otf/7poNu2N2pFrUSqV5Ofnc/z4cX70ox8xNjbGwsLCkouF7ojwuMlkorm5WXTIjoiI4IEHHvCaAPmt4HA4mJ2d5eTJkzd0l78bEM4l33nnHb70pS9x//333xVmx0qlkj179nD+/Hnm5uaYmJhgYWEBu91+p4d2Q5RKJStXrqS3t/dD7Zw+TgiamlVVVUxNTREaGopMJsPlcmE2m3G5XDidThoaGmhtbWVgYICWlhZ0Oh1Wq5XExET+7u/+jrVr1971Fb8Wi0VskwoLC/NIG8Dt4ufnR1lZGZOTk3R2dor+k3cTEomE3bt3Y7VamZmZoaamhqamJuLj4+9Ib6lglhAdHU1cXBzj4+O88sor/PVf//WSdrNeD45Cqu3EiRPMz8+L6io5OTm3nGv+MAj9gqOjo6SmphIZGXlLkmFms5nu7m6GhoZEebS4uLglpQUdDoe4MheKWQSEFI+wk/kgMfb4+Hg0Gg1ut5vR0VEmJyeXzUB2qchkMtG7UUgHjY2NfWijZG8hFIcJ1b9/rgjP5rvvvktCQgJBQUE4HA4GBwex2+04nU6am5vp7e1ldHQUnU6HXC4nPj6ewsJCCgsLl9R/5w10Oh2NjY1UV1cTFBSEVqu964pzhIWkUOR2KzJx3katVpOfn8/IyAg1NTVMTk5eJ3TgTQQZPJVKxfj4OC0tLSwsLBAcHHzb96NXg6PgMH/48GH++7//G4lEQl5eHsXFxaSnp3vkoRIKVfbv38/f//3fU1pa+oFWL3ClgvTo0aOiKoNKpaK0tHRJ6Y35+XnOnj0LQE1NDT/4wQ8ARGeLoqIiSkpKWLt2LQ899ND7/hzhIHp8fJzf//73SCQSOjo6OH78OH/zN39zV0xOQtWZ0DvX2tp6yym7O4FQaHU3vHd3AqlUitFopLGxkS9/+csUFhYSERHBwsICZ86cEXvMBDH8wMBAUlNTKSoqYtOmTXzqU5+6q987IdBcvHiR3/zmNxw+fJj4+HgKCgrIyclZ1mu5XC6xmvTDvCfCGKuqqkR/VG+1ndwORUVFREdH8+qrr2K1WsVM4J0kLCwMmUzG0NCQ2Jp0u6neZQ2OQvtDVFTUdakVi8VCXV0d3/72t0U3iYqKCh5++GF27NjhsRsgKiqKxMREamtree6556ivr+dLX/qS6C59IwSXjldffZW5uTmysrJYv349999//5Ly2Hq9ni9/+csAi9oe7rvvPvbt2yeuvG/WSjA/P09LSwvf/va3qaurQyaT8eijj7J37162bt16VzxILpeLubk59Ho9k5OTSCQStmzZ4hHPteXAZDJRW1tLRETEXVGY4W1kMhnf+MY3OHr0KBcvXkSv13P58mXx606nE7lcTmBgIMXFxWg0GlJTU/nrv/5rsfL7brjv3g+j0UhtbS2vv/46Bw8exOVykZuby0svvbTsaj4mk4m33nqLI0eO8PnPf56VK1cSFRX1gRO0xWKhra2Nd955h8rKSubm5oiNjRV38N5GEBcJCQl53+sHBQURGRlJRkYGOp2O9vb2D2U95SkmJiY4ceIETU1N5OXl3XZmYNmCY2NjI52dndTW1vLJT36S+Ph4wsLC0Ov1NDc309nZyeXLl+np6UGpVLJq1So+9alPUVhYeMP+muVCpVKRkpJCaWkpY2NjHDt2DKvVSlpammiSKbRzCK0JtbW1VFdXMz4+jtvtJjIyUrxJlzIJCBWSer1eLD5yu90EBgaKLiBarVYMwN3d3delSicnJ3nllVeor6/HYDAAV27Sm93E3mR6ehqdTseRI0dEMWN/f39RMeduQThLa2lpoaamBrvdzpYtW8jIyLjTQ/M6fn5+rF+/HqVSSVZWFh0dHYu+rlQqRXWppKQklEolkZGRaLXaRYoqnqCvrw+ZTPahbYmEtG9PTw9NTU10dXXR2NgoViOvXbuW1NTUZX9mAgMDcTgcjI6O8tJLL4kyhmFhYWRmZi5aXM/MzDAzM8PY2Bh9fX309fXR0NDA9PQ0sbGx5OTkoNFovO4cMz8/z+zsLDMzM/j7+7/ve2SxWNDr9YyNjZGVlXVX2L+NjY1hNBoJCQkhMDBwSeffyxYca2pqeO+99zh06BApKSmsXr0arVZLa2ur6Mbd0tJCREQEq1atYufOnfzlX/6lxyd0hUJBUlISu3bt4te//jXNzc3U1dWRk5PDunXr2Lhxo3hoOzMzw7lz5zh9+jRjY2NYLBbCwsLQarXLor0pl8vJysrCbDYvCnpWqxWDwYDRaBQVKtxuN1VVVaJDt5D2Gx0d5eWXXwau7DoDAgIICAi4K4oghEmhoaGB1157DaPRKLb0pKSk3JbepbCIuFakYSnYbDbMZjO9vb0cPXqUmpoaoqKi2LlzJ1lZWctyjY8Sfn5+5ObmEh8fT1FREU1NTYv6eYXsy4oVK7w+tp6eHuDKsyPcA4Jj/bUI/bd2u13U271w4YKoxalQKNizZw+7d++mrKzMI+MVFrpyuZzXX3+dmpoaNBoNMTExbN++fVFWSKfTodPpaGlpobGxkcnJSaxWK4GBgSQnJ7N27VoiIyO9uit3Op1MTU0xMDCAQqG44Xmn2+3GarUyOjpKZ2cng4ODREZGetTaShAIsNlsN92kjI6OYjabycjIIDw8fEmZvmXdOdbW1orq/GFhYYSEhNDa2iqaZhYWFrJ3716KioooLS312oceEhLCE088QUxMDKdOneKNN96gsbGRuro6fv7znwMsMiJ1u90EBAQQExPDv//7v1NcXExmZuaSxxsWFsbjjz+OTqcTvRj9/Pw4evQoR48eRSKRUFJSIq7Ajhw5IqrluFyuRdcXVP8zMzMpKCi4pXNUT+Jyuejq6uLNN9/kvffeo6qqCrfbTXFxMU899RRlZWW3daOeP38ePz8/MjIyiI2NXZYAefHiRY4ePcr3v/99nE4nBQUFPP/88x6RBvwooVKpUKlUooP81dyptOnk5CRnzpzhc5/7HAUFBURHRxMSEoJOp7vutWazWUyhOhwOgoODyc3N5dFHH6W0tJRdu3Z96HPA26GkpASZTMbFixfp7u6mu7sbgLfffnvRtYUFiHBGCVfOfrdv386+ffs8etz0fgwPD3PixAneeustXnvtteueB+HI5P/+7/84e/YslZWVzM/PI5VKPWo4MD09zdjYGBcuXGDPnj3vK9wwOjpKbGws//Zv/0ZSUtKSWkuWLTh+8pOfJCcnhyNHjnDy5ElGR0dFdYWioiLy8/PZvn27KAjt7Q9dLpezceNGMjIyuOeee2hpaWFoaEh0wBb6LAsLC8nLyyMxMZGUlBSKi4uJiIhYltRGUFAQ5eXl/Pd//zeVlZW8/PLL9PX1iVqQfn5+NDc309PTg5+fH2azGbvdvsiySiAxMZENGzbwxBNPkJycfMf6oAwGAx0dHVRVVXHmzBl6enoYGRnB7Xazdu1a7rnnHgoLC2/7/evv76ehoYH29nbi4uIoLi4WLcTCwsJu+YHU6/W0t7dz7NgxGhoa6O7uRqVS8Vd/9VeUlZWxYcOGuyItfTdwN50flpeXk5KSQllZGV1dXUxMTKDX6xkfHyc0NBSHw8HQ0BArVqzA39+fqKgodu3aRWpqqihGHR0dTUREhNd68ARN1OjoaAwGg5j9+KCWDIVCQVxcHJ/5zGfIy8u7I890Y2Mjvb29OBwOjhw5QmhoKFKplOnpaZqampiamsJqtXL58mUMBgNms5mVK1eycuVKjzrbCEF5YGCAzs5OEhMTiY6OFo2fBXNzqVRKVlYWsbGxS86mLdvdsnLlSlQq1SLDSoDw8HBKS0vJz89n/fr1BAYG3pGHTyKREBcXJ6b4BLWHvr4+xsbGGBoawmazUVRUREFBAYmJiSQnJxMWFrZs45VKpcTFxREXF0d4eDgdHR0EBwcvCo5DQ0OMjIzc0JVD+BkhISEUFBRQXl7uMbm4m2EwGLBYLKIlWX19PWfPnuXy5ctYrVZx1V5cXMy6detQq9W3veMTCj4WFhZob2/H5XJhNBrJzMxEpVKJ5603S7taLBYGBwepr6/n4MGDTE9PI5VK2bx5Mzt37iQ/P9+jhrw+bp+4uDjxzF+wd9Lr9aJYtnCvpaWlIZfLkUgkREREkJ2dLdYUeJugoCDUajUrV66ks7NTdM25EUJ/npCpys3NZe3atURHR3v9rBGuFBRNTEwwMTHB8ePHUSgUSKVSTCYTdXV1YsvY+Pg4UqkUlUrFxo0bSU1N9bhN2Pz8PF1dXSgUClasWEFKSgodHR3U1tbS1tbGyMgIW7ZsIS0tbVmMzJddeNzHrTE/P4/RaKS+vn6RMtAPf/hDKisrkUgkYqpX+H+JREJwcDCrVq3iW9/6Fvn5+XdEF/J3v/sdjY2NWK1Wjhw5gk6nW1TGHRAQwIoVK/i///s/1qxZsyyLC6fTyc9+9jN+97vfcfLkSfHfVSoV2dnZN1XnaGpqYnx8nKmpKQA2b97M9u3b+drXvna7w7l7tlYfDt/z7CUWFhY4dOgQx44do66ublH1r4BUKiUiIoJ9+/aRnJxMZmYm5eXldySzJvD73/+eP/zhD7z66qs3fZ1CoRCb/l988UWUSqVHd+aCjvRf/dVfYbFYiIuLY9WqVVRXV4uuT0qlkh//+Mds3Ljxw+5ib/hm+4LjHUI4YF5YWFi0Q5yamrqpL6NQhBMVFUVAQIBX3S6E8u6nnnqKo0ePYjabmZubw+FwiCLPBQUFFBQU8MADD7B69epbcbi4Zaanp5mdnRV77uBP74dg63UjFhYWcDqdYlorODiY4ODgpSwsfMHRx01xu91YLBasVivz8/PvK9AhmBcLGqbBwcF31MFGr9dTXV3NO++8w5EjR3A4HAQGBopet9HR0RQUFFBSUkJYWBgKhWJJmaFbxeVyMTExwR//+Ee6u7vF9PqBAwfIyMhg9erV7NmzR+y9/JCB2juuHD5ujfcTQPeEStByIoxbKpWKVjJCv9P27dvJzc0lIyODnJycZUltXM3dJvXlw8f7IbRt3e3P87WoVCqysrJwuVxotVqxx1UoEgwLC2PFihWkpaV5tUpeIpEQGhpKUVERCQkJzMzMMDExgUajEQ2kBYeV5drB+naOPm4ZoYT72Wef5dy5c5jNZrq6uggPD2fVqlX8x3/8BxqN5s+h4tO3c/Th4+ODL63qY3kQdDYBscVEkMC7myodPchH9Zf0Pc8+fFyPLzj68LFM+IKjDx8fH274PN+5k18fPnz48OHjLsUXHH348OHDh49r8AVHHz58+PDh4xp8wdGHDx8+fPi4Bo/1OQoK+YKQt/DnaqRSKRKJ5I42vfq4Pa52Kb/6MxTMWf9MqlZ9+PDxMcUjwVHof2toaKCmpobOzk5GRkbQ6/WigLZUKuXee+/lL/7iLygvL7+rvP58fDDd3d08/fTT1NTUkJKSwubNm4ErGrupqakkJyeLQgGeVOv34cOHD0/gkeD40ksv0draSn9/P2NjY9jtdiQSCfHx8Wg0GkwmE729vVy4cIGYmBhUKhWbNm3yxFDuSmZmZujt7eX48eNMTEzc0DMNruzOVCoVcXFxlJSUoFarUSqVd4V349zcHO3t7eh0OqxWqyg0f/nyZSIiIlCpVISGhpKWlsbWrVuJioq6qcTbcuBwOJifn6e/vx+TyYTJZEKv1zMwMCDKd8nlctRqNZGRkUilUvF9DQgI8Ni4Pi44nU5GR0cxGAxMTk6KZsILCwsEBASwa9cuVqxYQUxMjNfHZjKZGB4epquri7a2NqxWKy6XS3S6SEpKYtWqVV73R4QrvcBWq1UUIDeZTIyPj9Pf34/BYBAzLYLweEFBAUql8o7dkxMTE/T39zM4OHjDucnPz4/s7GzUavWyaDu7XC5MJhOHDh3CYDAQGRnJ3r17P1BdyOVy0djYiF6vx+FwUFxcTFhY2LIp5Cx7cHS73Rw6dIj29nbMZjMKhYKEhATUajWJiYlkZWUxPDwMQHV1Nc3NzaxYscJrwVGwPnE4HGKq12q14nQ6F90IAQEBovzTcj5MDoeD4eFhLl68yAsvvMDg4CAOh+N9X6/RaMjNzQVg1apVJCQkoFAovK6reiMkEglhYWFYrVZqa2uBK++vkE6Pjo6mpKSE6OhoSktLCQkJ8Whgt1qt6PV6Lly4gE6nw2Aw0NvbS21tLfPz8+IONjk5mdjYWGQyGREREQQEBNxxP8y7GYfDwcLCAjMzM9TV1dHb28vIyAidnZ3U1dVhsVgICgpCoVAQGBjoteDodDqx2+1YLBa6urqor6/n3LlzHD9+HLPZjNPpJCoqivT0dIqKiggKCkKlUnnNukp436xWq7iQ0Ov1jI2NMTg4SG1tLQMDA4SEhOBwOEhISKC8vFy8N70VHJ1OJw6HA5vNJjpfVFZWUltbu8hmS5gvJRIJDz30EHK5fNmCo8Fg4K233qK1tZWkpCTWr1+Pv7//DYVFBOcni8XCuXPn6OrqYmFhgcjISHJyclAqlUseE3ggOPr5+bFz507Ky8tRKBTs2LEDrVZ7nQP2unXrePTRR8UPxVsYjUZOnDhBd3c3drsdu93OW2+9xdjY2CJbmbVr1/LZz36Wxx57bNl8/ux2O0NDQzz77LOcP3+evr6+D/ye8fFxxsfHOXHiBBUVFaINVHl5ucctYm5GWloar7zyCo2NjVy6dIk//vGPwJVdscViwWKxYDAYeOeddzh27BgnTpwgKyvLo2Pu6uri8OHDPPPMM0RHRxMdHU1iYiJbtmwhISGBnJwc0Yi5uroauCKkPD09zb59+zw2ro86IyMjokH0b3/7W0JDQwkLC0OtVvPYY48hk8kYGxtj//79aDQa8vPzvTIuwaPzt7/9LX/4wx+YmprCbrcDkJSUJN5rlZWVtLa20tjYyG9/+1uv6PM6nU4GBwe5fPkyDQ0NHDlyhIGBAdE0YMOGDdx3332o1Wq2bdtGQ0MDZ8+e5dVXX2XLli2i8bSnsdvtjI6OMjIyQnV1NadPn6avr4+BgQHm5ubEBbjL5cJut+NwOPD396esrGzZ7MAcDgcDAwPodDoGBgYYGBjgjTfeoKys7IbmBRaLhe7ubs6dO8fXv/51zGYzAQEBdHZ28qMf/YjVq1cvy7g8soTau3cvDocDmUxGVFTUdR6Ocrmc0NBQr6c3JiYmqK2t5T//8z/FtIvL5WJ8fBybzbaoYKizs5MXX3yRTZs2kZiYuCwCwhMTE3zjG9/g0qVLjI+PA1cWEzfzIhRwOp3U19czMDDAhQsXcLvd5Ofnk5SUtORx3Q6BgYGkpaURExNDUVERjzzyCHDFSbynp4cDBw7Q0dHB7Ozs+6aNlxur1cr09DQFBQU8/PDDrFmzRtytBgYGolAoKCgo4PDhw5w4cYJjx44xNTWFyWTyyvg+aoyMjPDOO+9w4MABLBYLMpmMf/iHfyA3NxetVktwcDCRkZEMDw9z9uxZrz3PLpcLvV7PG2+8waVLl6isrBSfhbS0NNEIWyKRMDIywjPPPMPCwgIhISEeHaPb7WZwcJCmpiZqa2s5d+4cMpkMpVLJpk2bSEtLQ6PRoNFoxLT+wsIC9fX1vPHGG0ilUp566ikKCws9YkU3NzeHXq8XLdzGx8cZGBhgaGiIyclJpqenUSqVxMTEUFBQwI4dO1AoFCwsLHDq1CnefPNNnE4nJSUlFBYWLlu2RS6Xs2bNGvbs2UN4eDgnT57klVde4dChQ8THx/PYY48RHByM1WqlpqaGlpYWdDodo6OjWCwWHA4HUVFRfO5zn1tWX1aPBMcPmrDtdjszMzO43W7kcrnXHNidTidzc3OMjY0RGhoqplcSEhKAPwlr6/V6ZmZmxNSwsBpdKjabjfb2dmw2m2ibFBoaSlRU1E1TUS6Xi/7+fkZGRsRzisHBQZKSku5YcJRIJGLa+eobcmxsjISEBHp7exkaGsJsNuPv7+/x80ZAXJVv3ryZjRs3kp+ff92iQ6FQiBOnv78/kZGRd8QT827G6XSKBXXHjh3DaDQSGRlJeno627dvJzs7m5iYGKRSKbOzswwPD6PX64mKivK4C4Xb7WZubo6qqio6OzuZmZkhPT2djRs3kp6eTnp6OgkJCTgcDiYnJ+np6SEgIIDw8HDy8vI8llK1WCyMjo5y7tw56urqaGxsZGJigtzcXFJTU8nLyyMvL4+YmBjxfjObzQwODnLu3DmsVisZGRls2bKFmJiYZR9nd3e3uHBtaGhgfHxcTPH6+fkhl8uJjo4mLS2NxMREcSxzc3OMjIwAEBERQUREBFu2bCGw5ZG4AAAgAElEQVQxMXHZ0pcSiYTIyEhKSkqw2Wy0trYyPDzM8PAwHR0dxMbGEhISgsVioaamho6ODkwmE/Pz88TExBAdHU1GRgZFRUXLNia4Q5ZVRqORmpoa7HY7oaGhXjujCAkJQavVsmHDBtasWXNdUJ6fn6e3t5e3334bvV6/7Nf39/dHq9WK9i9+fn6sWrWKioqKm5652mw2XnzxRfbv309lZSUmk4mZmZn39Yi7k2g0GoKCgtiyZQsXL17EZDKhUqm8Ym+TkJBARUUFqampKBSK6wKjy+Wiq6uLM2fOcPz4cYKDg9m2bRsbNmzw6Lg+SggLxOeff54//vGP9PX18eyzz1JSUkJ2dvZ152A9PT2cO3eON954gy9/+cviQtNT2O12DAYDP/zhD0lKSmLz5s18+tOfJiIiAqlUitvtxmg00tnZSXV1Nd/61reIjIykoqKCr3zlKx5ZiLvdboaGhvj1r3/N888/z8zMDKGhoTz11FM88MADpKenv+/3XLx4kZ/85Cd885vfpKKigsLCwmUfH8AvfvELTp48SUtLCxaLBYlEgkwmQ6PR8MADD1BaWsqaNWuIiYkhICAAmUyGxWLh2LFjHD16lN/97nds3LiRiooKPv3pT3sk87dp0yYiIyPp7e3l3LlzGI1GDAYDP/7xj697rdvtRiaTUVxczO7du9mwYQMpKSnLWofh9eBosViora3lJz/5CfHx8ZSVlXHPPfd45drBwcHk5+fz/PPPExAQsOjDdTgcjI6O8txzzwFXfMvS0tKIjo5etgcqJiaGn/70p+LfhRVbYGDgTb9PLpfzmc98hu7ubtra2jAYDMsynuVmbm6O5uZmqqqqePbZZ5mZmSE3N5dt27aRlJTk8V1FTEwMkZGRyGSy6x6SyclJurq6eOKJJxgeHkalUnH//feTlZXl2zlehclk4umnn+bixYvExcXxgx/8gNLSUpRKJXK5XHydw+FgamqK3//+9zQ0NBAXF8cDDzzg8UxGT08PFy5coLq6mr1797Jz504iIyORSCSMjo7S2trKs88+KxriOp1OvvCFL7Bx40aPHeV8/etf5+zZs3R3d/PAAw+watUqVq5cydq1a6/byZjNZvR6Pfv376e+vh673c6xY8fIzs726Hl8Xl4ewcHBbN26ldjYWEJDQ1GpVOTl5YkFfsICtqenh/Pnz/Pmm28yMzODRCLhiSee4NOf/jRpaWkolUqPZYEyMzP53ve+h06no6WlhUuXLvHLX/4Si8WyKIOXkJBAYWEh3/3ud0WbvOUuUPR6cDx79qy4+9m4caNXJk0BPz8/AgICbrhTFQ6lGxsbsVqthISEEB0dTUhIyLL16Uml0tvO0wcGBuLv73/XNdf39/czMTGBwWBgaGiItrY2+vv7CQ0Npby8nKysLIqKiggODvb42KVS6aLdqSBU0NHRQWtrK+fPn6e3t5eIiAgyMjL4xCc+4RUX848SDoeD3t5eFhYWUKlU5OfnX1ceL+wum5qaxAlemHQ9fUQSFBREdHQ0xcXFpKenExUVhc1mo66uTlyYNTY2EhgYSGpqKuvWrWP9+vUkJyd77HOWSCRoNBoyMjLYtWsXSUlJxMXFER4evuien56epqWlhbNnz9LQ0IBGoyE9PZ28vDzCwsI82g+cm5tLfHw8LpeL8PBwAgMDCQ4OFrNYcCWz0t7eTn19PZcuXUKr1ZKfn09MTAyZmZmkpqZ6vJjJ399fnHddLhezs7NER0fjcDiw2+34+/uzfv168vLyKC4uJjExkcDAQI98th4PjkIxhsvlYmFhgQMHDnDx4kXkcjnr168nISHhjk/4woRQVVVFZWUlcKWKUSg6uJN9hUKZ9eTkJBaLxWvFLR+E2+1mYWGBmpoa2traaG9vp7a2FqPRiFQqZc+ePXzqU58iMzOT6Ohor4/P9v/ZO/Oots4z/3+1IQlJILFqAYTYzWKwAdvgBWyTYGdxnLVxJmnSdMmcJNOetqfNJL+cNEub9LSn6clMOpNJ08bZXGfi2EnjeE/ACwZjm83sIBCbJBBa0L7f3x/uvWMwtrGRhNPczzkcG2334ep93+d9n9XrhcfjwczMDOrq6lBfX4/Dhw8DuBhpW1VVhW3btkVcrpsdMkxeKBQiISEBycnJl/m/PB4PpqencerUKQwPDyM/Px/bt28PaY7ZlYiLi8OyZctw//33Q6lUgiAIaLVaal1pbm6Gx+PBhg0bsH79evzwhz9EUlLSrFNvqFGpVJDJZFi7di3y8vIuU3IEQcDr9WJ4eBgnTpzArl27IJPJcO+99+LWW28NqZ/sSpDpYPPh9Xrh8/ngdrvR0NCAtrY29PX14amnnkJxcTFSU1MjnnPJ5XIhEokQHx8PsVgMg8EAFouF6Oho3HHHHaisrERxcTF8Ph9cLhdVcCSUsQ1hG8mBQABerxcmkwkEQWBqagoffvghPvvsM3C5XNx555147LHHIhJWfS05W1tb8ec//5laPKOjo5GRkYGtW7eGdVJdC7fbjZGREbS2tuL9999HZ2cnpqenl0yeSzEYDPjss8/w6quvQqvVArh4LysqKrBhwwY888wzEAgEEcspuxSHw4GvvvoKDQ0N+Nvf/gaDwYBgMAgej4cf//jHqK2tRWlpacTl+iYgFovxu9/9Di0tLeDz+VTOKrng+Hw+HD9+HPX19Xjrrbfw2muvYe3atSgsLIzIJjcmJoZS3MeOHcM777yDzz77DDqdDl6vF8FgEBwOB8uWLcOqVavAZDJhtVqpPMxw8MgjjwC4eIKc7x4YjUYcPXoUv/rVr+Dz+ZCbm4uPP/4YIpFoya0WTqcTR44cwblz56j84PLycjzzzDPYuHHjklmr1Go1PvjgA7z11luwWCxUzurtt99O5TeePHkSdXV1yM7ORm5uLpYvX46ioqKQ6ZSwrVxjY2Noa2vDRx99REWJDg8Pw2KxoKSkBLfccgv4fP6Snhrdbjemp6exa9cutLe3Y2ZmBjweD/fccw/Wr1+PVatWLcniTnL48GE0NTXh5MmTUKvVmJmZoZ47f/48AoEApqamUFtbG3ElTqbpyOVyOJ1OSmmr1WoAQE5ODtavX0/5A8KNx+NBT08Pzp07h/Pnz1PReQaDAR6PB6mpqSgrK0NVVRVUKtU1/bzfVjgcDjIzMyGRSMBisajF0WazYWpqCl988QUaGhowMDCA2NhY6HQ6dHd3w+VyYeXKlWGfLx6PhwrI6ezsxNjYGPR6PTweD5WK5ff78dVXX6G3txdisRgCgQAJCQnIzMzEAw88ALFYHNL5cjXLkkajoWIsxGIxysrKqOovS6UYnU4nTCYTtFot/vrXv2JkZATBYBDl5eUoKCiASqVCdnY2ldcI/F+eI5maEm5GRkYwMTEBq9VKFSKw2WxUNDCpN/R6PdRqNZqampCcnIwVK1YgNzcXZWVlyMjIWNR4DNtInpmZweDgIA4ePEjdYNKhSu6wnE4nFVIfaZxOJyYmJtDZ2YkTJ05gYmICbDYbmZmZ2LRpE8rKypCSkrIkctntdkxOTqKurg5NTU1obm6+7HVqtRperxcGgwHJycmQSqWIjY2l8vrCvemIioqCQqHA6tWrkZCQgImJCdhsNlitVqjVahw5cgRJSUngcDgRUY42mw3d3d348ssvcfr0aTidTni9XqrABJvNRkxMDJxOJ/R6PVWRZKl37jcbDAbjsgR0sgRfT08PDh48iIGBAdjtdsjlcuh0OgQCAYyPj4PFYlHKiAyMCvU4JP2ddXV10Ol08Pl8UCgU857aRkZGcOHCBTCZTIjFYqSnpyMjIwO5ubmQy+Vh9Y8SBAGLxYKOjg6cOXMGvb29uO2227Bu3TqsWbMGBoPhskYMJOTGhGzMECp8Ph9sNhtV61qtVuPw4cPg8/lQKpXIyMjAqlWrIBAI4HK5oNFoKDcOecAhKyCRgYQ8Hg8ikSjk37XNZqPmMABqkzYzM0MFCZEVdGw2G2ZmZtDf3w+9Xo/h4WFK1vj4+BtefxhX+oL+wVWfvBqdnZ2oq6vDH/7wB+qmGQwGOJ1OcDgcSCQSfPDBBygsLIRMJrvRy9wwLS0t2Lt3L9555x1MTU2Bx+MhIyMDL774IjZv3rxk1WdaW1vR2NiIN954A1qtFm63e1YJJxLSdODz+ZCcnIzbbrsNt956K1avXh3ynfHV8Pv9VJWjo0eP4u9//zvli/rXf/1X3Hrrrdi+fXvY5Th79izeffdd/Pd//zcAUIqZzNEiEYvFyMnJQWlpKX73u9+Bz+ffiE/55oqKWjg3NJ/ffPNNHDlyBMeOHQObzUZGRsasCF+z2QytVovo6GisXLkSa9aswSOPPIK4uLiwjMPp6Wns2LEDLpcLMpkMDzzwwLwmSovFgkOHDqGrq4sKuEtLS8Ojjz6K+++//6p+uMXidruxf/9+/PnPf8bw8DBKSkrw/PPPQyKRYGZmBl9++eW8+dMsFgt33XUXJBIJBALBZdVhFoNOp0NdXR1+//vfQ6PRwOl0ory8HPfeey+ysrJgNBoBXKzK1dfXh9OnT1NlNYPBIOx2O6Kjo5GWloaUlBRkZ2cjPz8fGzZsQHx8fEj9kocOHcLf/vY3vP/++2AwGIiPj0dycjJKS0sRFRUFsVhMBVaazWbo9XocOnQIDoeDUqi/+tWvsHnzZpSXl1/rcvPO57ApR7fbTSUIczgcqn7eb3/7W3R1dcFkMuHuu+/GY489htra2hu9zHVD1mF86aWX0NHRgfHxcfh8PmzcuBEbN27Ev/3bv0EoFC5ZEE5TUxPq6urw8ssvX1a1B7h4YpPJZHjyySfBYrFw9uxZDA8PU0UVSktL8Ytf/CJiJbyA/6u5aLPZ8PXXX+Prr7/Gm2++iYSEBGzevBkvv/wyMjMzw3pPzWYz2tvbce7cOarAPZfLpfJVdTodOjo6sH//fjgcDkRFRaGiogLPP/88CgsLr3cR/1YoR4PBgJMnT+Kll16C1+tFamoqfv7zn0Mqlc7y33k8HthsNrS1tUGj0WBsbAxqtRq33HILSktLUVVVhdjY2JCdLAKBADQaDZXrJpFI5j1hBQIB2Gw2uN1u9PX14ejRo3jvvfcQGxuLvLw8vPrqq8jJyQm5mVCn06Gvrw8vv/wyenp64Ha7qdMquSbabDYUFRXNSn0xm80YGhqCy+WCSCRCYmIiSktLUVJSgszMzBtS5mTg3P79+3Hq1Cl8/vnnlOUkEAhAKBRCLBaDw+FQFj42mw2hUIiqqiqqXi7ZgtBgMKCzs5Mys5J+3q1bt6KysjJkQW7kCbezsxMMBoOqKpSYmEh1dSJNpoFAAB6PB2NjYzh+/DjOnj2LL774AqmpqXjwwQfxyCOPoKCg4Grjb94nwmZWJY/cZAQbuXjW1taCw+Hg0KFDaG9vx+joKGw2W0Ts2DMzM9BoNPjiiy/Q1taGyclJavdGVrg4c+YM0tLSqGoQkfY5EgRBfdlzSU9Ph1KpRHZ2NioqKqiKMF999RWlJDkcDgYHByGVSiNWTJvsKhAbG4v09HSq5iKZxOtyua5oQgoVQqEQWVlZEAqFSExMpELjbTYbJQtZyaejowMajYaKTo6KigrrKeKbChkdmJOTQ1WYKS0tRUxMzKzNBBmJzufzIZVKkZiYSNU9tdlscDgcuO2220LWUYbFYi24ridpHiaVuVqtRk9PDzo6OnD48GFIJJKQrj1OpxM9PT04duwYent74Xa7wePxIBAIEBsbi/j4eKpQQlZW1qw5arPZoFQqYTQaKWXU2toKnU4HpVIJs9mM4uLi6yrg73A4sH//fhw5cgSdnZ0YHR2lok9JUzRpeiRPfgKBAElJSaiqqroslc1kMiEtLQ1erxdmsxmTk5NoaGhAc3MzgsEgioqKkJKSsmhXmUgkmpU6IhaLKUU9H8FgEHFxcWAwGODz+RgeHsbAwAAGBwcxMDCAgoKC65Yh7Cv/pZNILBbjkUceQVRUFI4dO4bBwUEMDw9jamoqIspRp9OhubkZf/rTn2AymWZ1w+jq6sL4+Dh6e3tx5513ori4mFoIIhk0xGAwwGazER0dfdlz69evx8aNG1FQUID8/HwIBAKUlpbC6/ViamoKQ0NDmJycRFtbGyQSCdUmKpIkJiZCqVRSCjMS/k/gok8iJSXlMj8x6W+QSqUoKChAaWkpPv74Y+zfvx91dXU4ePAgCIKgleM8CIVClJSU4Mknn4RMJkNeXt68r2MymeDz+VSJNJvNhvj4eHz88cc4evQo6urqUFJSgvT09HnHdSSQyWS47bbbwGQy8e6772L//v145513UFFRAaVSGZJ5QhAE9Ho9la5hNpuRmJgImUyG3NxcbNq0Cfn5+cjPz7/mZ+n1evT09ODZZ59FY2MjeDweLly4gOeeew5KpXLB66XZbMZLL70ErVZL1ZetqKiARCKhlOHy5cuRmpqKhIQEABfnDHk4uNrcNRqN1Em3ra0NZrMZhYWF2L59e0jiSK6n+DqTyaRyqxMTE2GxWPCf//mf0Gq1aG9vx7Zt267/OyZNYlf4CTl+v584c+YM8eMf/5jg8XjEj370I+L48ePhuNRltLe3E6+//jrBZDIJBoNB8Hg8QiwWExKJhODxeASTySSioqIIgUBAlJWVEa+88grhcDgiIhuJ0+kkDAYD0d3dfdnP5OQk4XK5CL/fP+s9JpOJePfdd4m77rqLiIqKIuLi4ojq6mpi3759hN1uj6j8Y2NjxN69ewkGg0EoFArie9/7HjExMUEEAoGIynElgsEgMTIyQuzdu5cAQEgkEuK73/3u9X7MtebNzfpz3QSDQcLn81339+fxeIjh4WFi586dRHp6OrFz506ip6fnRkQIKR6Ph9izZw/x3e9+l+BwOMRPf/pT4uDBg4v+XK/XS0xNTRG1tbVEWVkZsXHjRmLPnj1Ee3s7odVqCYfDQXi93gXfx2AwSHi9XmJycpI4d+4c8dZbbxG5ubnExo0bibfeemvBco2PjxPr1q0jvvOd7xAvvfQS0dbWRlgsFsLhcBBOp5NwOp2Ex+MhfD4f4ff7Cb/fTwQCASIYDC5IRr/fT9jtduL//b//R6xatYoQCoXEwMDAguULB16vlzAYDMTq1asJhUJB5OXlEdPT04TP57vSW+adLxHPUyBNNaTtmPyJBMnJySgrK8NPfvITABcTTcnqCk6nE5OTkzh06BBVoV6r1UY86Z6sazhfJF1UVNS8UWEikQiVlZUQCARUcfLe3l688847WL16dUSiRYGLtv+hoSF0dHRQ8vJ4vMtK9S0lDAaD8rMwGAyqJyDN/JCWjOuFbCotl8sRFxcHvV5/U3Q/IU3oTqcTf//739HV1YW4uDiUlZUhLi7uhqND/X4/HA4H9Ho9MjIyUFNTg7KyMkgkEvD5/Os+SZHdesigJhaLhYcffhi7du2iOvosBLFYjJ/85CdUgwOVShWy8m+kZYhcQ/1+P+x2+5IXKiHlIv5RpJ7JZCIQCFy3ayckypG4JEl4QRf9h9mQyWRSWjoSxMXFobCwkIoAu7SZpsvlglqtxtmzZ2GxWKhmmpGSjYTJZF53egubzUZOTg7i4uLw6aefYmJiAnq9HgcPHoTT6QyjtLNxOBzo6+tDW1sbWCwWEhISEB8fv6SFFOaDzWYvSfrQt41LN0cej+em2YSkpaVRTQ9GRkaQlJQEq9UKsVi8qNSJYDCIpKQklJSUoKamJiR1ZtlsNsRiMaVwP/744+u6jwKBAPfdd9+i5ZiPYDBIuXTMZjP8fv+i72Eo8Pl8MJlMcLvdVDT9jeiZRStH4h/RUNdTusfj8cBkMiEYDMJisUCv1y9WjAVBppDMl6Zhs9lgs9ng8/kirhBDBUEQs5JmIwnZb/LAgQPYv38/NSmrqqoi4k+mufkwGAwYGhrChQsX8MwzzyxZe7W5sNlsKmDQZDLBaDQu2rrB5/ORkZGBw4cPh8VK4nQ6MTg4iPXr199QcEk4MJvNGB4exmuvvYbW1law2WyqY8dSotfr8fnnn2N0dBRer5dqr3a938uilaPT6cSePXuoVkzLli276ut9Ph/UajX27t2LtLQ0rFq1ChUVFYsVY9F0d3fj1KlTGB8fh9/vh0AgQFpaWsQCWgiCgN1ux+effw6n04kHH3zwuqpokCHiHR0dsFqtNywH2XMyGAwiJiYGGRkZV319MBikqqT88Y9/xIULF8Dn87F+/XqsW7duQcEHkcRqteLEiROoq6sDQRCorKzE6tWrl1qsmxqLxYKoqKgFB9OQm94333wTzc3NSElJQWpqakQ62y+ElpYWfP3115iYmEB+fj6WL18esuC1cChGtVqNc+fO4a9//StqampmFQtfKGSeok6nQ2Zm5qKi8AOBAE6cOIH6+nqcPHkS/f39qKyspKr/LFWOOMn4+Dh2794Nl8uFsrIybNmyZVb/3oWyaOUYCASoEk5GoxFZWVlXNFkRBEF1SBgbG0NlZSXS0tIi1s/xSjKNj4+jpaUFzc3NcDqdkEgkSE1NRW5ubkSUo8vlgs1mw8TEBE6fPg2LxYLs7GysXLlyQTmXVqsVfX19OHPmDIxGI5UEeyN4vV50dHSAy+VCJpNdUTkGg0E4nU6Mjo6ip6cHDQ0NaGlpAUEQUCqVqK6uvq6oukgQCATQ1dWF5uZmtLS0QCwWY8WKFTfNTvxmg0zRaGtrg1QqvWK06qW4XC6YTCY0NTWhs7MTXq8XGzduRFJSUlhK9vn9fqp/4kJOBzabDT09PWhqaoLL5UJOTg7y8/MjXlh7IQQCARgMBjQ0NODcuXPU+nojRVNMJhMmJibQ3t6OlJSU61IUxD+qEjmdTthsNkxOTqK+vh69vb1wuVzIz8/H2rVrUV5ejqysrOuW7VLcbjfVbD4+Pn7Bfyup/MlDzsDAADgcDlQqFcrLy2+oRmzIAnKOHDkChUKBTZs2UY1H5wrv8/mwZ88e1NXVwev1YsWKFUtS8f1SfD4fjh07hk8++QSNjY0AgKKiIqxduxabN2+OiG+KzAlrbm7GiRMnMDU1Bb/fjxdeeAEqleqqATWBQABqtRp79uzBvn37ZuVH3ogpweVy4fjx40hISEBBQQEqKiqozyAIgvITO51OaDQa7Nq1Cw0NDTh58iQYDAaKi4uxbt06/PCHP4xYIBApG3DlnTtp/t+1axfq6uqgVqtRXFyM2tpalJWVRUzObxJerxeTk5P4y1/+gvXr119TOQaDQWi1WrS1teHZZ5+FXC5HZWUlfv7zn18xUX+xOBwOdHZ2Un0Jr7boBwIBDA4O4syZMzhx4gSioqJQVVWFDRs2hFyuxUJuPhsaGvDmm29Sh4mqqqobyl/u7e3F2bNnsX//ftTW1i5obpJzikywHx4eRm9vL44fP46Ojg6sWLEC3/nOd1BdXY2MjIyQmFOnp6dx6NAhXLhwAdXV1bj33nsXJKfX64VarcYLL7xAxY2oVCrk5OSgqKjohk70IVOOWq0WXV1dePzxx/Haa6/NWtTJxf/111/HmTNnEAwGkZ+fjx/84AdUYvZSQO5S3nvvPfT29oIgCMjlcjz99NMoLy+PWK+/4eFhHDp0CO+99x7VlurAgQNgMpnYtm0bHnrooXnf19LSgnfeeYfqoXhpqTSlUokdO3ZctymLw+FQXQN2796Nt99+G4WFhTCbzTAajbjnnntw9uxZDA0NQa/XQ6/Xw+12g81mY/369XjsscdQU1MT1oaol+J2u6ko4+zsbFRWVl52QiEIAmq1GvX19fj444/hdDohl8vx/PPPo6CgYMly7252dDod3n//fYhEoqs2hCZjCP785z9TPTPz8vLwxBNPYMWKFWFTjHa7He3t7fj3f/93/Md//Aeys7Pn7cjg8/kwOjqK06dP4ze/+Q1MJhNiYmLwi1/8AtXV1VRS/s2CzWbDmTNncPz4cbz99ttQKpW477778MwzzyA+Pv6GPrOgoIByfxw+fBirV69Gbm7uvK/1eDywWq24cOECLly4gK6uLhw7dgwcDgdpaWlYv349Xn75ZSQmJkIkElER9qFgfHwcb731Fp544okFFXpwu904c+YMTp8+jffffx8TExNgMpnIy8vD66+/joKCAkil0huSZdF/EZfLxdq1a9HU1IT29na0t7fjL3/5C1QqFaRSKaxWK5Ve0NraCuDiF3XnnXciOTl5ybojuN1udHZ2or6+niriLZfL8cADD6CgoACJiYkRi7oie5LZbDYqmMbpdKK1tRVerxdjY2MAgBUrViAjIwN8Ph+tra04e/YsGhoaMDU1BbvdDr/fDy6Xi+LiYqxcuRJbtmy57oWfx+NhzZo16O/vR1tbG3p6ejAzMwO73Q6n0wkWiwWNRkP1l/R4PFCpVFi9ejU2btyI0tJSJCQkREQxms1m9PX14ZNPPoFOpwOHw8GqVauo4g4ulwtDQ0Po6+tDb28vZUrLzMxEaWkpioqKIqbEv4lYrVacPXsWSUlJlwWpeb1ejI+Po7OzE5OTk5icnMTQ0BASExORlpaGjRs3oqioCAkJCWGbR06nE0ajERqNBqOjo7MS251OJxwOB6amptDV1YXBwUG0t7dDp9OhuLgYFRUVqKmpoYI1IglBEDCZTFQPRaPRCLPZjJmZGRgMBkxNTWFsbAyTk5NYvXo11q5di5KSknl7ay4UgUCAlJQUVFRUoKmpCQ6HA0ajcd7TnkajQVtbG1Vg3uv1UubnjIwMFBcXU+tQqO+d1+vF9PQ0enp6KLfOXBn1ej2mp6eh0+kwODiIjo4OylUXExODvLw83HPPPSgqKkJ8fPwNj7+QKMcNGzagvr4eJpMJXV1d2LlzJ1JSUpCeng69Xo+JiQnY7XZwOBzk5OSgqqoKjz76KIRC4ZIsTMFgEHq9Ho2Njfjoo4+g1+uRkJCAnJwcPPbYY0hPT4+o0maz2eByuRAKhVSbGK/Xi4GBAQwPD+PgwYMALvaNq66uRkxMDHbv3o329nZ0dXUBACoK3uwAACAASURBVNX9IjY2Fps2bUJ1dTXWr19/3feXx+OhoqICOp0ObDYbIyMj0Gg0CAQCCAQCOHz4MBWZTEb/lpaW4vHHH8eqVavA4/EitthMT0+jpaUFb775JhQKBZRKJbRaLZU6YrFYUF9fjyNHjkCtVmNkZAQymQyrV6/Gpk2bbproyZsVMkKSw+FQlgMmk4lgMIiZmRmcPXuWigo0mUwoKytDeXk5iouLsX79+rCPA4/HA4fDAavVit7eXvB4PCrNwWw2w2AwoLu7G4cOHcLQ0BB0Oh2kUimqq6vx4IMPhi1YzO12w+12UzWlCYIAi8WCz+dDMBiE3+9Hf38/5cMbHBzEyMgI1X7JYDBAIBBAJpPhRz/6EaqrqyGXyxe1yYiKikJqairuuOMO7N69GxaLBZOTk5RPj9z8MJlMtLW14dChQ3A6nUhLS0NGRgbWrl2LmpoapKSkhD2OIBgM4ty5c5BIJEhLS4NMJpu1jnV2dmJgYADt7e1obGyETqeD1WqFQCBAXl4ebrnlFjz99NOLliNkhcdtNhs0Gg0OHjyIffv2we/3Izo6GtHR0RCJRFAoFLj77ruRkZFB1clbCvx+PywWC5588kmcP3+eKmB8++23o7a2NiQ39XoZHBxEZ2cnzp8/j7GxMWg0Gpw4ceKy15E+RAaDQVXKJ7+/oqIilJSUYPXq1bjtttuoEm43it/vpyJgyQVwfHwchw8fplr/lJWVoaysDLm5udcq7BsW2tracOTIETz77LNUru2lO2syt4nMP8vLy8Nrr72GzMzMRe0o8S0pPN7X14c33ngDu3fvBpfLhVQqRUpKyqydu1KpRElJCbZu3Yrt27dTDa4jMRaMRiNOnTqFH/zgB7DZbAgGg7P84+S/gUAA0dHRSE5OxnvvvYfc3NywWTe8Xi8+/fRT7Nu3DyUlJTAYDAgEApDL5ejo6KBcETqdDm63G8FgECwWC3FxcZDL5cjPz0dtbS2ys7ORlpYW8pN3IBBAY2MjDhw4QG26ydZQfr8fEomEKnf35JNPIikpiaqvGglLWkdHB1599VUcPHgQXq8XfD7/sjQbu91OHSJIXZKamopf/vKXKC0tvZHc6vB25QgEAlSvvImJCepLJ08YfD4fKSkp1ORZqq4XZJjv22+/Da1Wi0AggKeffhrr1q1DQUHBoqOtbgRy90vuzklT0Fzsdju0Wi127dqFzZs3Q6VSUbVElUol0tPTkZaWBqlUGpJedX6/Hy6XC1qtFk6nEy6XC3q9HgKBAAKBAGKxGHFxcRCJREsSlUoWkj969Cja2tqgVquh0WjgcDioKOjk5GTq3uTn56OoqAhCoXCxgVbfCuVos9nQ19eHPXv2oLe3FxqNBomJieByuRCJRMjJycHy5cshl8uhUCggl8sjWqifNO1+8cUXeO+99zA2Ngaj0Uh972SDY6FQCLlcjry8PFRWVkIoFIatMEUwGER3dze6urrAYrHQ3d0Ng8EA4OJ4JTteJCUlUZVkuFwusrKyIJFIEBsbi+TkZIhEIvD5/LDISTY6JvPL7XY7VaQhISEBQqEQIpEIWVlZ4HK5EauPDFy09nR2dqK5uZnyJZKN1IVCIVasWEG9lslkYsuWLZDL5ZBKpcjNzaXa9V2nvOHtysFisahFMjs7O1QfG3LIyCuPxwORSET1Qly2bFnEuljMhVQ2MpkMDocDNpsNKpXqstfZbDaMjo5idHQUNTU1yMnJoUyD8fHxiI+PD+mJnOz6fSXH/VITGxuL7OxsqhtEf38/BgYGMDMzg8zMTMjlcsjlcmRkZCAlJWXee0pzZcjC41arFUlJSZBIJIiJiYFEIqFKMebl5UEgECxJVRSyfduWLVswOjqK4eFhTE9PQyqVQqFQQCqVIicnB7GxsdT/w628mUwmUlJSwOfzYbVa4fP5EBsbC4fDAZlMhpiYGCQnJyMjI4OyAnE4HGRmZoa1+fKlkEXFyWL7LpeLOjmKxeIlO7gAF+d0eXk5EhMTqaYPWq0WABATE4M1a9ZQlgkWi4UtW7ZAJpPNG4i1WMLWz/FmxWAwoK6uDrt370ZSUhLWrFmDhx566KYrcUZzU/OtODnS0HxLiGyz45uVQCBAmTHJIuiRbktF843nmzpY/unmMw1NCKCVIw1NiKCVIw3NPw/zzuelLZ9OQ0NDQ0NzE3It7/Q3dYdMQ0NzOfR8pqFZIPTJkYaGhoaGZg60cqShoaGhoZkDrRxpaGhoaGjmQCtHGhoaGhqaOdDKkYaGhoaGZg60cqShoaGhoZkDrRxpaGhoaGjmQCtHGhoaGhqaOdDKkYaGhoaGZg60cqShoaGhoZkDrRxpaGhoaGjmQCtHGhoaGhqaOdDKkYaGhoaGZg60cqShoaGhoZkDrRxpaGhoaGjmQCtHGhoaGhqaOdDKkYaGhoaGZg60cqShoaGhoZkDrRxpaGhoaGjmQCtHGhoaGhqaOdDKkYaGhoaGZg60cqShoaGhoZkDrRxpaGhoaGjmQCtHGhoaGhqaOdDKkYaGhoaGZg60cqShoaGhoZkDrRxpaGhoaGjmQCtHGhoaGhqaOdDKkYaGhoaGZg60cqShoaGhoZkDrRxpaGhoaGjmQCtHGhoaGhqaOdDKkYaGhoaGZg60cqShoaGhoZkDrRxpaGhoaGjmQCtHGhoaGhqaOdDKkYaGhoaGZg60cqShoaGhoZkD+xrPExGRgobmmwVjqQW4Qej5TENzOfPOZ/rkSENDQ0NDMwdaOdLQ0NDQ0MyBVo40NDQ0NDRzoJUjDQ0NDQ3NHK4VkENDc1VsNhu0Wi3UajVYLBYEAgFYLBbGx8fB5/MhEAggkUio17PZbGRnZyMqKgoMxjc1roVmoXg8HhiNRlitVurHYrEgPz8fcrkcYrF4qUUMC8FgEJOTk+jp6cH09PSs55hMJhQKBTIzM5GUlLREEn47CAaD8Pl8mJmZwdTUFCwWC/R6PdLT0yGTyaBQKK743kUrx2AwCL/fP+sxFosFANTix2TSB9RL8fv9IAgCBLHw4EEmkzlLmTAYDOon0pCyB4NBjIyMYP/+/fif//kf8Pl8ZGZmgsfjYc+ePUhNTYVSqURJSQkYDAaYTCZiYmLw4x//GLGxseBwOBGXnSa8kGODHB8GgwFnzpxBT08P+vr60NXVhQsXLuC5557Dtm3bUFpaGpLr+nw+MBgMsFism2LT5fP5cP78ebz66qtobGyc9RyHw8Gdd96JJ554Ahs3bqTmBr1OLgxybAWDwcvWQXJNZTAYIAgCTqcTMzMz6OzsxOnTp9Ha2opDhw7hsccew+233x4+5TgxMYGOjg58//vfn7XYP/7440hOTgafz0d0dDTWrl0LlUq1mEv9UxAIBDA5OYkXX3wRzc3NmJycBPB/C8rcyUHeTw6Hg61bt0IikYDH4wEAysvLoVQqkZqaitjY2IguCK2trbhw4QK++uornDhxAkajEW63GwwGA8PDw9TrdDodpqam0NbWhvT0dJSXl6OoqAg8Ho9eCP5J6enpQW9vLzo7O/Hll19idHQUHo8Hfr8fPp8PgUAAfr8ff/zjH9Hc3IyDBw8u6nrBYBAulws1NTVQqVT43ve+h02bNlEb9LmYTCa43W4QBAGpVHrF1y2WQCCA0dFRuFyuy57z+/04cOAAuru7kZKSgpSUFNx7773Iz89HRkZGWOT5Z6KpqQkNDQ348ssvIRaLUVBQgPT0dBAEAa1WCyaTCalUit7eXgwPD2NoaAijo6PUGAwGg+DxeGCzr67+FqUcBwYGUFdXB4PBgEAgAODign7s2DEIhUKw2WxwuVy0trYiNTUVCoUCKpWKWuDZbDaSk5Nnmd3CicVigUajwf79+5GXlweHwwGdTger1Yr8/HxkZ2dj9erVYbu+w+HAgQMH0N7ejuHhYdhsNgCzdzuXQj7OZrNx6tQp8Pl86rTV2dmJpKQkKBQKbN++HQqFIuz30efz4dSpUzh69Cg6OzvR19cHvV4Pj8dDyS4UChEbG4ukpCRkZmYiJiYGfD4faWlpUKlUyMzMBJfLpZXjPwl2ux06nQ59fX1oa2vD+Pg4Jicnodfr0d/fj5mZmVkWEiaTCaVSifz8fFRWVi76+n6/H2azmTKZxcTEICkpCXw+n5JvaGgILpcLBEFgeHgYVqsVBEGgsLAQAoEAMpkM5eXl4PF4Idtker1enDx5EkajEUKhEFlZWdQBweFw4PTp09Dr9bBYLBgbG4PD4cDKlStxxx13IC8v75oLdziZmpqCWq2mfvd4PBgcHASPx4PD4cDIyMhl76moqEBubi5ycnLCLp/ZbIZWq8XQ0BAYDAYmJiYgkUhAEAS1popEIhgMBpjNZpjNZthsNkgkEqSlpaGsrAy1tbVYtmzZVa+zqG9Ao9GgubmZOt4SBAEGg4Fz585Rg4zFYuH06dOIj49HYWEh1qxZA5FIBAaDAR6Ph2XLliE9PR0AIBaLw+qLmpycRHNzM15//XVs3rwZRqMRXV1dMBgMqKmpQXV1NeRyOZhMJlgsFlgsFmJjY8Fms0OymDudTnz99dcYHR2F3W6f9++c77FgMIi+vj4AmLXQREdHIyEhAUlJSaisrAy7cnS73Th48CAOHz6M/v5+eDwe6sTL4XAQExMDlUqFtLQ0ZGZmYu3atZDJZIiJiUFiYiKio6PB5XLDKuN8+P1+ygxDbuKuBJvNBofDoZX3NQgGg7Db7dBoNOjo6MDXX3+Nffv2wel0UvebhMFgQCAQgM1mQyAQYOXKldiyZQtWrly5aDm8Xi8mJycpE//BgwdRWFiImJgYMBgMGAwGNDY2Ukq6t7cXFosFfr8fq1evhlgsRnFxMXJzcxEVFRWyk6TP50NzczNMJhOEQiGKi4tRU1MDNpuN6elpGAwGTE1NwWq1Ynp6GsPDw9BqtUhLS0NWVlZElSNBEPD5fLBarfD7/ejp6cGJEyeotcjhcODEiROIiYnB9PQ0WltbZ70XuGgtrK2tRUZGRkhlDwaDcDgcAC7OTT6fj2AwCDabjejoaMzMzGB4eJhajwKBwGWbMSaTidjYWGRnZ6OgoAA7duxARUUFBALBVa+9qL/C4/FQmvpKBAIBWCwWWCwWqNVqfPHFF9RNZ7PZSE1NRVJSEgiCwEsvvYTy8nLExMQsRqwrUldXh0OHDsFisWDv3r2zbuJXX32F+vp6/PrXv0Z8fDzi4+ORmpqKF154ARkZGYiPjw+JDKFcdF0uF8bGxvD000/jlVdeQWFhYcg+ey7kDn3nzp2YmZmBz+ejnouNjYVKpcIvf/lLrFy5Ekqlkjrh3gz+n5GREZhMJpjNZkxMTMxauOeSlZWFvLw8JCcnR1DCbx4GgwHvvvsudu7cifHxcTidznl96EwmE9HR0bjnnntQVFSEwsJCrFu3bkFmrYVgMplw5MgROBwOuN1ujI2N4ac//ell3/F8spEKQKfTobq6GhUVFWExs/L5fCxbtgxbtmyh1pEnn3wS+/btw9GjR7Fv3z5YLBaYTCb09fVdcwMXaux2O3p6evDb3/4WQ0NDmJqawuTk5Ky16kpzhpzfBw4cgMlkwvLly5GRkYGoqKhFy+X3+2G1WvHuu++Cw+FAoVDg3nvvxe23347q6mo8/fTT0Ov1aG9vR1dXF5qbm6HVauF0OqnPiI2NhVQqRW1tLe68807k5uZSlstrEbHtyaUmQi6XS5kw5HI5srOzkZWVBYVCEZKbeiU8Hg+YTCby8vIwPDwMj8czSz4Wi4WMjAxMTExQk83lcoVssLJYLEgkkssCUXJzc7Fs2TIwGAzKRNTT07Pgz527WwoHLBYLQqEQlZWVaG5uhl6vp55TKpXYtm0bKisrER8fDw6Hs+RK8dSpU2hpacHx48dhs9ng8Xjg9Xop89qVEIlESExMxC233IItW7bQPqBLIAiC8iG3tLTgo48+wsTExKx7qlAoIJPJEBcXh4KCAqSkpEChUCA3NxexsbEQiUTg8/khU0JOpxNdXV3wer3UY5fOBwaDAQ6HAw6Hg6ioKMTGxiIjIwMJCQk4ceIEcnNzUVlZicLCwrCuPaQs5LxgMBhYt24dsrKyUFNTA7fbDZFIhLS0tIhbV3Q6Hbq7u9HY2AiXy0VZhDgcDoRCIaVM5nP/CAQC7NixA3FxcUhLS0NqamrIAu0GBwfR2NiInTt3Qi6Xo7S0FPfeey8YDAaio6PBZrMRGxsLuVyOdevW4Tvf+Q7cbves9ZrD4YDL5SIxMRFJSUnX9R1H3LCdmZmJ5ORkyGQyAEB6ejrS09ORk5OD+Pj4sJoT5HI5ioqKoFAo0NzcjLGxMej1enC5XKSmpiIlJQUFBQVQq9Xw+XwQiUQQiUQh+7JZLBaSk5PB4XBmLdAqlYoyuRiNRkxNTUEul1/1s2ZmZmCxWDA1NQWJRBKRkHhyoZm7sBEEAY/HA7PZDODihImLiwu7PFdDrVajsbERBw4cmLVYBgIB6m+40iLE5XIRDAaxYsWKb61yJK09er0eKpUKIpEIXC6Xck2cPHkSfX19EAqFlI9PKpUiIyMDKSkpSExMxPLly6FQKCCXy8MWNOZ2uzE6Ogqv10uNTz6fDz6fDx6PB6FQCIFAAJFIBLFYDLFYjKysLCQkJCAqKgrLli1DUVER4uPjI25KT05ORkJCAtLS0hAIBMBkMsHlcsMWJHQlnE4ntSkHgJiYGKSnp0MsFkMqlVLumispxy1btkAoFCImJuaapsqFYrFY0Nvbi/r6evT19SEpKWmWRZHJZILH44HH4yE2NjYk15zLojXR9QwogiDw0EMPYePGjVizZk3ETxd33303tm3bhmAwiCNHjmDv3r348MMPkZCQgB/84Ae47bbbkJWVRUWzkakHoZKTy+Vi+fLlEAqFsx4vKirCd7/73csevxqnT59GQ0MD9u3bh82bN4fVpApcVCoOhwNNTU2X5W319PRgbGwMWq0WxcXFKCwsRE1NzZKeHsncS3IXDPzfpBYKhRCLxfOaTt1uN+x2O/bv349HH300ojLfTLS3t6OhoQEffvghnn/+eZSWlkKlUmFgYADHjh2jTJIFBQVUoNWOHTuQkJAAgUCwYNPVYnG5XOjr64Pf70dUVBREIhEyMzORl5eH9PR05ObmUgo6MzNz1nsff/zxiMh4NUhr0lIyN62ssLAQO3bsQEpKCoqLi6FUKiMuU0dHBw4ePIhdu3YhEAhg27ZtuP/++yMqw6KUo0KhwPLly9HS0nLNvD3yuT/84Q94//33oVAocP/99yM7OxtpaWnIzs5ejCgLgs1mU7syMjgkKioKW7duxZo1a5CTk0OZX0hCucBzuVysWLECMpkMw8PDsNvtAIBDhw7B4XDgjTfeWPCuceXKlcjPz8dDDz1EpcyEE4IgEAgEKKf9pZDO/H379uHgwYMQCATIz8/HL37xCxQVFS35KZKEwWBAoVBg69at2LhxI9avX3/Za9xuN6anp/Hmm28iNTV1CaRcWtxuN44fP4433ngDLS0tsFgsOHr0KKKjo6loy9jYWKxcuRI//elPUVJSAolEgujoaAiFwojmGZpMJkxNTcHr9YIgCCQnJ6O4uBg/+clPYDabYbfbQRAE9Ho9OBwO0tPTI34qu5kJBAIYHBzEW2+9hWPHjlGPZ2dn4+GHHwabzQ67qXk+/H4/PvjgAzQ2NoLJZKKgoABKpTLi68iilKNUKkVubi6YTCYCgcCsiNW5kM+ZzWY4nU6YTCZER0dDoVAgPT0dd999N+RyOQQCQVjNG5cWJiD/7/f7Zw2EcE1ucpeoUCiQmJhIRWEZDAYMDAxcl9+QNClEqsIIWf1m+/btMJvNlL+2p6eHOmlbrVbY7XZYLBZ4vV58/vnnMBqNqKmpoSKUw00gEEBfXx+Gh4dhMBiox6OioiAQCFBZWYk1a9ZgxYoV8yYA+/1+xMfHU+Px24Rer8fg4CA+/vhjdHd3w2AwIBgMQqlUIiEhASwWC0qlErfccgscDgfWrFkDmUwGHo+3JEpnamoKWq0WbrcbwWAQTqcTWq0Wx44dg8Vigc1mo8ZcWloazGYzNm3atCQR0zcjZKGC/v5+KucauDhXwhUUeS1sNhsGBgbQ2dkJg8GA6Oho3HHHHUhPT4940ZBFKcekpCTk5ORc5mhms9mzFsJgMEidPICL4ddGoxEHDhwAl8ullEVFRQVkMhmEQmHEbkQwGMT09DTsdjsCgUBYJzmDwYBQKIRSqYRCoYBGowFw0eY/NTUFt9t9TZ8reX8jvRgxmUyIxWI8+eST0Ol01Kn3k08+gclkAkEQ6O/vh8vlgtfrhVarxe7duzE1NYVly5YhOzs77OHpgUAAdrsdX3/9NTo6OjAxMUE9x+FwIBaLUVFRgWXLliEpKQk+n++yscpmsyEWi3HPPfeEVdabkZGREZw4cQI7d+6kNrlRUVGUSZXFYiE3N5c6US91RO/o6CiGhoaojZrZbIbVakVvby+V7E2OOZlMBrVajeXLlyMxMXFJTkSBQGBWsMjcqleRhIwEPX78+KxiBWQa09xUnEjJabFY0NDQgMHBQdhsNiQlJeHBBx+EUqmM+JoX0tUqKioKEokEKSkpsxZCo9EIi8UyaydP4vF4oNFo8NRTTyEnJwcrV67Ejh07UFVVFRG/RTAYxPDwMFpbWxEXF4eysrKwX3Mu5GbhnXfemTUA5juFCwQCrFixArm5uWE3pc6FzWajvLx81gn3gQceoPKk/vd//xfNzc3o6OhAU1MT9Ho9Ghoa8Pvf/x5//OMfw+Y4J+np6UF9fT2effbZy6LWyOTlZ555BmlpaVi2bBmefPJJrFq1asl9PjcLTqcTRqOR+l0kEiEvL2+WIiGD1G4G6urqcPjwYep3Uvl4vV7I5XKkpqaiqqoKbrcb/f39+Oyzz8Dn87Fjxw7ccsstEZdXo9FgenqaUjyRKNwxHz6fD2fPnsXRo0fxwQcfzErLqqqqgkqloipdsVgsREVFRcyK4nA4MDAwQG1co6OjkZWVFTEf9qWETDlyuVzk5OTg0UcfRVZW1qwJNTExAYPBQO3kdTodLly4gPHxcXi9Xvj9fgQCAYyNjYEgCERFRaGkpGTeyMhQkZmZiczMTEilUkxMTGDv3r3o7e3FAw88gOXLlyMuLo6qshFqyGCV3t5emM1m+Hw+mEwmfPTRR7OU4XzRYSwWC/Hx8SgrK4NSqYRKpcKKFSuoJOtwM9fkTX4/UVFRqK6uRk5ODtRqNQiCQE9PD4xGIxobGzEyMkJFPYaDM2fO4OjRo/jyyy8vy7lLTk6mIukGBwdhMBjg8/mwd+9eqFQqWjn+g8nJSQwMDFC/u91uDA8P46233kJKSgqSk5Mhl8tRWFgIpVK5ZCfHYDAIvV6P8fFxKsKShMPhYNOmTVSQmlQqRSAQwPnz52Gz2dDa2oqSkhIUFxdHrOi3w+FAS0sLmpubZ1nQVq5cifT0dDAYDBQXF0Mmk0VEJrPZjHPnzmHfvn3UCZuku7sbJpOJqgfL4/EglUrxxBNPIC0tLWxrIonD4UBPTw+8Xi/S0tJQWVm5ZH7ikK2mSUlJyM/Pn9c+PDk5CYPBQNm1NRoNRCIRWltbqVOl3W7HzMwMVW1nYGAALBYLCQkJoRJxFsnJyVCpVMjOzsbp06fR0dEBrVZL1S/NzMyEXC4Pi8IpKCiAyWRCamoqrFYrVXvy/Pnzs153tbJyExMTUKlUKCgoAJPJhEqlgkwmW7KyUwwGgwrjT01NRWdnJ/R6PXQ6HUZGRtDX1xfWU0dPTw9aWlrQ0tJC+UcFAgFiYmKQmZmJ+Ph4iMViCIVCTE5Owm6348yZMxgbG4NMJrtpTkNLidfrhcPhoMad1+uFwWBAfX09YmNjIZFIoFKpqGTv8vJyqkxkJM2DwWAQNpsNVquVSvi+NOetpqYGW7duRX5+PvWeQCCApqYmfPHFF9BqtbBYLGFVRCwWC2lpabBarXC5XFSdT9IEHBsbS1X3AS4qdTIPm0xHCbXplyAIeL1edHd3o62tDR0dHZe9ZmJiAhMTE1SVMx6Ph9TUVOTn52Pz5s2UjzlceL1eTE1NIRgMgs/nQywWw2g0zlrXyJSXUKWNXAnWiy++eLXnr/rkzMwMdDodPvnkE9x3333Ytm0b1q1bd5mmJ3OhMjIykJGRgZUrV+LOO+9EVlYWoqOj4XK5qFOlz+eD0WiE2WyGSCSaNcBDCYfDQXR0NKRSKY4fPw632w2z2YympiYqiV0mk0EgEIR84pMFEAKBAM6ePTurNuncKvOX/n7pY5OTk+jr68PJkydx8uRJ8Hg8ZGdnX1c6SDggiwUUFxfj7NmzMBgMVOmupKQk5OXlhfyaBEFg79696OjowNjYGCQSCTZs2IBt27bhueeew8MPP4x77rkHd9xxB7Zu3Qq5XA4Gg4ETJ04gOTkZXC73evMZXwr5HxEZXrzakyaTCVarFU1NTbMed7vdmJmZgV6vR29vL5qamnD+/HnI5XLExcWBy+VGvNyZ0+lEXV0dRkZG4Ha7ERMTgzvvvBMvvvgi7rrrLkil0lnz1mg0Qq1W4/Tp0ygoKEBRURGkUmnYZGQymZDJZOjp6YFarcbk5CS8Xi/l+96+ffus6Mvx8XEMDw9jYmICZrMZXC435NGZbrcbWq0WP/vZz9DY2EgFBM7lUqtLIBCAyWTCF198gaysLIjFYiQmJoZUrksZHx/H/v37YTQa4XA4MDk5iejoaPT29qK7uxvd3d0YGRmBz+ejSn2GgHnn86KUY3R0NFJSUnDfffehtrYWeXl5C95VMBgMKrFTLBZjenoaTqeTykuz2+2Ij49Heno6JBJJWHamAoEAKSkpKCoqgkQiAZPJxMTEBMbGxtDX1we1Wo2qqqqwOO95PB4UCgWmp6fh8Xio3MGF1lu99HGHwwGNRoOWlhYolcpZVS2WAiaTCT6fj6+++go6nQ4WiwVcLheFhYUhqac5FwaDAZFIBKVSiaKiIvzmN7/BB2T0AgAAIABJREFUtm3bsHr1aigUCggEAqpmL5/Px9jYGFUXWCKRQCKRoLy8/Hou+U+pHKOioiCVSlFaWoqtW7eipKQEDoeDilT1eDxUizqLxYKmpiaMj4/D5XIhMzMzYkF0ZEk6lUqFVatWIScnB7/61a9w1113UY0N5s6ZiYkJNDc3o6WlBQUFBSgoKAhrqg5BEJiensbQ0BBsNhssFgtuv/12PPDAA3jqqadwzz33YMOGDVi/fj3Wr19P1UY+f/48Tpw4AZFIBJVKFdK1p6urC6+88gqamppgtVrBYDAglUqpvNCioiI8++yz+N73vocdO3Zgx44dyMvLg0QigdVqpXpTrly5EtHR0WFZkwmCQHR0NLq7u+FwOGA0GqmcW/Knvr4edXV1OHLkCMbGxuDxeMDn8xdzMJh3Pi9qu8fhcBAbG4sVK1bc0PvJhF0mkwmHw4Hdu3fD4/HA4/HAZDJBq9VidHT0suTdUBEVFYW4uDhqYSR3al1dXRgZGYFQKAxbnUMej4eUlBTU1tZCLpdjYGBgXvPp3Mc8Hg/UajUMBgOcTiecTie8Xi/Gxsbgcrnw5ZdfwuVyUeX4ForL5aKCWEJhyiZTY8gThcvluiw/MpSkp6eDz+dDpVKhuLj4ijtKMtKXyWRS5dDIrjLf9hw4snqMWCymFnehUAifzwedToehoSG0tbVRpsLh4WEqFy05ORmVlZUR67gSFRWFnJwcJCQkQCaTUQv2lbBarRgYGKCi04eGhlBRURE2czDZNmnDhg2QSCRoa2tDbW0tioqKUFBQgISEhMviC2ZmZgBcdBEUFhZCp9OFNP/bbrejt7eXyv8UCoW49dZboVQqqVzVdevWzXIxxMXFISkpCdPT0+jr64NGo8HMzEzY3F1isRhr1qzB8PAwRkdHqdQ/0vUEAGNjYzCbzZicnKQ6K5Hf5+TkJDgcDjIyMiCVShc1FpeuL8o/IKtXrFixAhcuXIDBYKBqYJJ5V9XV1WEbxGRieHx8PFauXAmFQoHf/va3MJlMMJlMVy1SvRhYLBZEIhF27NiBO+64A1ardUHvM5lM2LVrF5qamjAyMgKtVgufz0fVgv2v//ov2Gw2bNy4ETKZbEGDg8w/nZqagsfjCdvADwVkRCLZOYUcF4mJiQsy95CNUsm8XLLgs9frDWnLom8ipJ/2UnPjxo0bAVxckNrb2/H73/8e/f39mJ6eht/vx4ULF2C1WmGz2bBs2TLEx8eHLY/wUnMfg8GgTv3X2jyTm6CGhgZ4vV4MDw/j3Llz+Jd/+ZewyAlcnN9ZWVlITU2FwWDA6dOnUVNTA7FYPO+cJNNmhEIhNBoNuru70dvbi6ysrJCNSTLViTydpaWl4Wc/+xmUSuUVfe5kul5/fz+GhoZgtVoxNTVFpfaEmpiYGKxatQoqlQoTExMYHR2FTqejDgPAxSLnOp0ORqMRR48eRUNDA2QyGb7//e/j1KlTiIuLw8MPP7zosXjdypH0P4jF4pC19iFb2ixlqyAej4f4+HgsX74c0dHRMJlMEbu2SCRasElAKpXihRdegM/nQ09PDz799FO8/fbbVOUak8mEzz77DCMjI2Cz2aiqqlpQyofP56NOjzcrDocDn376Kerr61FcXIxt27ZBqVQueMyQ/fzq6+tx6NAhABfz3xQKRdij8L7pKBQKJCUlISsrC6dOncLp06exa9cuymrx97//HZs2bcK6devC1tNPo9FQfrLrKZc4Pj4OvV4f8W4XwMUofrlcju3bt19XQf66ujpMTU3h9ttvD/mGTSKR4O6778Zjjz22oN6RQqEQt99+O7766iuo1Wr86U9/QmFhYVgLkCQkJFDF68l2cyTPPPMM+vv7UVdXh1deeQVOpxMajQa//vWvEQwGsWbNGvD5/EXft+tWjmazGW1tbSgtLUVMTEzIfFvz9eKKNHNPI5FkoddksVhUYeXs7Gxs27YNGo0Gra2tGBwcBEEQMBqN6O7uxr59+1BWVrbgfMiJiQno9XqsXbv2hjtrEAQBt9sNtVoNrVZL+TZEItGi/CeBQADvvfce6urqcOHCBQwODiI9PR08Ho8qYn+t9zscDnz44Ydobm6GxWKBWCzGhg0bsGrVqhuW69sCGSGYkpJCmd6ampowPDxMda/5+uuvIZPJQt7TD7gYoXry5EkqTuBKlbjm48svv0R9fT38fj/VeWfVqlURm+dMJvO6x77H46ES80NFZmYmnnvuOXi9XuTm5i64b2RUVBQVT+L3+6/Z2SYUMBgMai0m74Pb7YZGo4Hdbsfg4CC6urrg9/up9BiPx4Pq6mpUVVUhMzNz0WPwut9ts9nQ398fsiR0r9cLt9tN2Y8vTUiluTpxcXGorKxEf38/fD4fpqenqRJuY2NjqKurW/AEY7FYMBqNGBwchFarRUJCwg313PN6vTCZTDh16hTGxsZgt9upyL3FlKQKBALYs2cPenp6MDk5CY1Gg4mJCapSz3yvJzdbZN9RnU6Hzz77DOPj4wAuLhYVFRUoKiq6Ybm+bQiFQuTl5YHL5aKgoAA6nY7yVTc3N6OyshJ2uz2kpwryOzx9+jSkUinYbDbcbvc1/ZvkRq2+vh7nzp1DIBCAQCBAVlZWWALDLiUYDMJoNFL1m8l5RDbfXQpSUlLw2GOPXff7yACoSMhNKjqbzQav1wuv14uJiQkQBEHlqRqNRoyOjqK7u5vyQ5JuqqqqKqpp/WJZcp9jf38/WlpasHPnTrS3ty/Y90ZzESaTiccffxxpaWlIT0/Hm2++iWAwCJfLBY1Gs6AgGAaDgcTERIhEIthsNjz//PN48MEHsXz5cqSlpV2XPOPj42hsbMRTTz01qwTZI488gtLS0hv9M0EQBFVvkcvlUl29/z97bx4W53ne+39mn2GGfRn2TewgISG0Cwntm+UqqWM7duvYbY5PksttanfLaU97znUS16fpcXKlSerGqZvNsR3HrhdZ1mLJ2pDQwqIFJHYYYNiHAYZhdub3B7/3MWixJcGAnMznH0nMCB7eed/nfp77ue/vVxLDvpG+vj6sVit2u53q6mouXrzI0aNH6evrIzo6mqVLl/I//+f/ZMWKFUERgHsgOjqap556ikuXLjEyMoLf76e5uZnq6mpyc3PZsmXLnP0sm81Ge3s7x44dw+v1cvLkSaKjoyksLPzUz85ut3P+/Hna2toYHh5GJpOJqsxAtBTdOOa/+7u/E9W0UquQTqcjLCxsQeTr7hWr1cpLL700w8M1UEjtJr/85S9pb2+nu7ubiooKkRK/3Y5Vr9ezZ88e/vAP/5D8/Pw5Gcs9BcfJyUmOHj1KUVERBQUFd71K7OjooKKigt/85jcMDQ1hs9kwm80zlE2kApk9e/bM20rLbrdz+vRpbDbbvPy8z+LIkSO43W7Cw8M/UylitikiSeHGaDTy93//93z/+98nJyeHffv2sWrVKnEmfCPSSs/hcPD6669TWVnJlStXRGBMSUmhrKyMFStWzJmiisfjwWQy8f3vf5/f/OY3t9zddnd3MzIygt1uZ2xsTPhfLl26lJ07d1JWVkZpaWmw+X8aPp+PiYkJLl++TEpKCqGhoeLaNjU1UVdXR0ZGBp2dnfT09NDe3i4qLGFqoaZUKuc8pSqZ1YaGhmI2m2lpaaG6uvpT5dfGx8dpbGzk//yf/0NLSwsulwuFQsG6devuesF3L0htQ2+++SYjIyPiTDs1NZWioqIZ1arSnz09PdTU1ODxeO6rymmfz8fo6Cg+n4+EhAT27NkTkKKr6upqamtrOXDgAPX19eKozev1EhoailwuF/fb9CAptXA999xzc9qec9d3sVKpRKfTce7cOSwWC319fcTGxgpHjVsxOjoqFHBkMhltbW2cPn2ao0ePCsUI6ZfV6XTExcVRUlJyW+eEQCClAy9dusTExITIeS8ETqdTpEXHx8cJDw/H4/EQERExo3DE4XBgtVpxu93U1tbS0dEhRN7vFqnnyefzERoaSmNjIwMDA2i1WoaHh4Uxa0xMDHK5HK/Xi9VqFQLGfX19HD58mKtXr9LZ2QlMFbsUFRWxbds24uLiZnU+LZPJKCgooKGhAYvFwvj4ONXV1TQ0NNxyYTA8PIzdbsftdpOQkEB4eDhGo5Ft27axceNGSkpK7hsrrfsFScno7NmzJCUlCfUbQJzxpKen09XVxeDgoCizh6nPZ9GiRaSkpBAdHT2n41IqlRgMBuLj4xkYGGBkZITLly+zZs0akpKSbtqF+f1+4W5fW1uLw+FAqVSKBfednFHPFpVKRVFREW1tbfT394tUflJSEr29vTOukXT/jo2N0d3dvSCFQ7dDWvhKIgahoaHk5OQERPShqqqK48ePc+bMGaxWK0qlUswZOp0OlUo1YzEmk8mIiYlh6dKlbNiwgcLCwjnttb3r31Cn05GYmMiRI0d499130Wq1xMTE8PDDD9+2J6e2tlbIe8lkMlwuF2NjY8K9W9plyGQyjEYjO3fu5Nlnn51XyyCr1UpbWxvHjx/HZrMJqbOFKM4ZHBzktdde45VXXmFwcBC5XM5vfvMblixZMsN41GQycfbsWVFWDzN3kHfbhiKXyzEYDGzcuBGTycS1a9eor68HpiTvVqxYwebNm9FqtYyNjXHmzBkmJibESn46MpmMdevWsXPnTp544ol7vRQCpVLJ008/zZtvvsnRo0dxOBz09PR86vvlcjl6vZ7du3eTlpYmFP7nopLtd5HDhw/z8ssvc+nSpbv+vyqVii9+8Yts3bp1zo23JTnA/Px8+vr6GBgY4OjRo2zevJmUlJQZrSeSCH5VVRVHjx5lfHxcHBuUlpaya9eueVkU6XQ6/vRP/5SwsDCOHDnCL37xCyH7KKmB3U4eUvpaIDJmkjzn9J/zaUxMTDA4OMjVq1eZmJggJCSElJSUgGwc3n33XQ4dOiTGpNPp0Gq1jI6Oir9PH7dKpaKkpITHH3+c3bt3z3mq+q6Do9FoZNOmTaxfv566ujq6u7tpbm7me9/7HiqV6pZVZG63G4/Hg9vtFl+71epIOkz9kz/5E4xG47xKUlmtVsxmM/39/RiNRsrLy/nmN7+5IHJso6OjophGupZdXV309fXNuCmlCq0bb3iYSkVFRkbe9U0cHh7On//5nxMeHs7HH3/Me++9B0BzczMmk4kPPvgAmUzG5OTkDMUUCaVSSVxcHN/4xjfYsWPHnLmIy+Vy9u3bx5o1azCbzZw7d+5Td8iRkZEYjUYhyq5QKESlbzAw3hpJHu5uCQ0NJSkpiX379gXMtFwul/PEE08wOTkpqqqff/55XnvtNRYvXkxWVhZ2ux2z2UxrayvXrl0Tu7VHHnmE0tJSVqxYQURExLxlhBQKBbt37yY7Oxu1Ws3Jkyfp6+ubsfu5HStWrGDv3r1zeq+eO3eOb33rW6xYsYL4+HiSkpJ4+OGHbxmEpd33f/7nf3LgwAGuX79OQkKC6IkMxDP04IMPotPpOHjwIC6Xi/HxcdG6Yzabxc+MjIwUEqT79u0jOjo6IA5Fdx19pNX4Qw89RGZmJpcuXRK7rekB71ZqLxIKhULYkcBUj+GaNWvYvHkzS5YsIS4ubt6kqKTWh3Pnzoly75UrV7Ju3ToWLVq0IKlVg8FASUkJ9fX14ubweDx4PJ6bGqFvhV6vJyUlhT179tx1cJfL5YSFhbFu3TrCwsIICwujurqa/v5+kc6cjuSiEhERwcqVK0lISCAlJYWtW7fOuQtHSEgIiYmJhIeHo9PpPjU46vV6QkNDSU5OnrOf/7vO4sWL+cIXviB25JIQx+DgINHR0SQnJwsZPgmDwSCcOtLT0wO2mJTOrzds2IDT6eSNN94QAvJDQ0PijEqyxrNYLHi9XnJzcykvL6e4uHhBPAENBgPp6ens27ePpKQkurq6RNCWqnDb2tqAqQZ46X5du3YtixcvntMgZDAYKCgoEAsISXRAOl+ejtfr5eDBg5w5c4b29nbCw8PZu3cvGzZsCIjeNMDq1asJDQ3FaDRitVoZHh5mZGRE6G/L5XISExPJzMwkJyeHFStWkJCQELBYcU9bM7lczkMPPUROTo5wYBgfH8ftdosziNsREhKCSqUSVihyuVxUvi1fvpzY2Nh5DYwej4fm5maOHTvGkSNHgKkbcyF9/iIiIti1axcHDx7E4XCIXdqnoVarUalUqNVq4uLiKC0t5atf/eo9t08sXbqUjIwMCgoKeOWVV7hy5cotd/KS2obRaOSRRx6hsLAwoHZGGo0mIKLMQWDVqlXExcVRU1OD3+9nZGSEK1euCKUWyYVj+sRoNBrJzs6+W23aeyIqKoqysjKMRiPnzp0TwfHatWtUV1eLxZL0HMTHx7N27VrKysrIzMwMmHLPpyHNbzt37qSoqIjOzs4ZtmBjY2N8/PHHwNR5pHQdJUu9uSQhIYE//MM/5Be/+IVQ15JSkzeKsLvdbn75y1/S1dWF0+mkoKCAL33pSyxbtixgPrLLli0jJyeH5cuX093djclkoqOjg+joaHEGWVJSQlFREVFRUbNqDbsTZJ9RvPHpL/7/6vjHjh3DbDZz+fJlXn755alvfJud41e/+lVycnJITk5m7969Ik8s6V3OJyMjI7S3t/PYY4/R09MjqlRffPFFysvL71kzdi6YnJzku9/9Lu3t7QwNDXHgwIFP3TlKk0B5eTkZGRlER0fPiWC7VI3q9/s/dac2vWn39yBt+Xn9BT+zUkuS15v+7+k1ATdyo2PMfODz+ejv76etrY22tjbOnTvH66+/zujoKAqFgoKCAvbu3cv69etZu3atSKvfD9z4HN34b2kODNQ1lUwdTCYTV69e5W//9m8ZGRmZceQlvW9yclII+v/FX/wFO3funBcPT+l63GrOCdBZ7C0v9KyCI0xN4v39/TgcDkZGRmhtbf3U92dmZhIaGipSZAvVENvf38/Vq1c5deoUP/zhD7Hb7ej1ejZt2sRf//Vfk5+fH1B5pDuhsbERu92Oy+Wip6fnUwtsYmJiiI2NJS4uDoPBMKPxOMic8zsbHD8vuFwu7HY74+PjWCwWYWMkk8kICwsjMTGR2NhY4SgS5BOklh3JiqqtrQ2TyURVVZWoSpU0px944AHKy8tZtWoV8fHxC7L7ngcCExw/r5jNZq5cucLp06epqKjA6/USFRXF3r17+cIXvjBvLuFBPpcEg2OQzz0+n4+Ojg7a29tpa2vj1KlTmM1m0ROakpLCQw89xIYNG+5rM4I5IBgcgwSZI4LBMUiQ3x1u+TwvTE4zSJAgQYIEuY8JBscgQYIECRLkBoLBMUiQIEGCBLmBYHAMEiRIkCBBbiAYHIMECRIkSJAbCAbHIEGCBAkS5AaCwTFIkCBBggS5gXuWUBkfH+fIkSNUVFSQlJRESkoKcXFxpKSkEBYWhl6vFxp8kmh1b28vBw4coKOjg+HhYR544AE2bNjA4sWLZ/gUBgkyH/h8PiorKzGbzVitVtLT08nKymLRokW/DxJ4vzNMTk4il8uZnJzE7XbT0tJCQ0MDXV1dDA8P09raKizySkpKSEpKIi0tjQcffHChh76gOBwOfv3rX3Py5EnhwXorG63Q0FC2bdvGl770pXm1EVxo7ik4+v1+ampqqKio4Pjx4xiNRhITE4mJiSEhIWGGlJnNZqOjo4P+/n76+vr4+OOPMZvNDA8Po9VqiYqKIjEx8b5xT/D7/Xi9XiYmJhgZGQGmPM1sNhtmsxmDwUBERATJycnExsYGRKJtbGxMOIKr1WphIq3VatFoNMjlcgYHB4UY+erVqwMi6yQJs1utViYnJ/H5fPT19TEyMoJSqSQ3NxeYMme22Wy0t7ej0WgwGAwsWrRImJXOpTPHvSC5iUvWWj6fD6fTSUtLCx999BGdnZ2Mjo6SnJxMcXEx4+PjFBcXBwPkZyBpX9rtdiwWCw6HA4vFwsjICB6PB5jy5DMajRQWFs6Z357f78dms9HT08PIyAh2ux2NRiPMv9vb22lpaaG3txebzUZ/fz8ejweVSoXX6yUvL++29nr3I5KB+fTANRcaox6Ph7Nnz1JRUYHJZAJuHRwjIyNZtGgRTqdzVj8vkPh8PoaHh4EpfVqFQkFNTY1wkUpNTSUiIuKu5sl7mtl9Ph8/+9nPqKyspKmp6abXjUYjixYtIisri8bGRlpbWxkaGrrpfceOHSMjI4Ps7OwFDY6S1ZYUDMbHx+ns7KS6uhqZTEZ7ezuNjY3813/9F7m5uSxdupSHH36Ybdu23eRSMBd0dHTwrW99i+HhYaKjo4U6f2JiIlFRUahUKk6ePMng4CAymYx3332XmJiYOdeplQLjxYsXcblcOBwODh06RE1NDXq9nm9961sA9Pb20tDQwE9/+lPi4uLIy8vjv//3/y40Lufa/PZumJycFBqcY2NjwFQw7+/v5yc/+QkVFRUMDg6K9xcXF7Nx40a+973vBTU5b+BGQWi3283k5CQdHR1UVFTQ29vLmTNnuHLlinjek5OT2b59O9/97neJjo6ek3H4fD5MJhNvvfUWly9fprOzk7i4OPr6+mhqasLr9aJQKFCpVOh0OhISEkhPTyctLY1z584JA+T7Hek6OxwOvF6v0Fa+0fLvXnG73Vy4cIHh4eGbrof0b7lcjlKpFKYCC8X0e+/GPycnJ5mYmBAm3dLn/txzz6FSqVi0aBFf+cpXKCkpuSvh9Hve9rhcrlsaFgMMDQ1htVq5dOkSXq9XrCIltFotsbGxPPnkk2zbto3S0tJ7Hcas8Hg8jI6O8o//+I8MDw8zMTGB3W6nra0Nu90uxj05OSn+7nQ6uXbtGt/97ndJTU0lKysrIALlMpmMvr4+rFYro6OjOBwOJiYmxG4xLi5O7LqBm9Tr54LGxka+//3v89FHHzExMSEmREng+emnnwYQhscej4e+vj6GhoaoqakhJydHWPUsBH19ffz85z/n4sWLdHZ2zkgdSeLL090IIiIiyMvLY82aNZ+LyXM+kCbnnp4eOjo6sFqt9PX10dXVxenTp+nr6xPXUUprTr+mdrud5uZmxsfHCQsLmxM7OqfTydGjR9m/fz/Nzc2oVCrcbjdJSUmsXr2a9evXC1eajIwM4fijUChwu93C0mohPmOfz4fb7WZ8fBy9Xj/DfFvKWLlcLkZHRxkYGODQoUOcOXMGs9ksTJLj4uLIzc3l1VdfvefdeF1dHWfPnqW3t/e2dnhqtVo4mzz44IPExsbe2y89S+x2O62trXR3d9PW1iYWt62trZjNZpEVknxIlUolGo2Gvr4+AEwmE/n5+WRkZAQ+OMpkMlatWkVfXx9tbW03Tcw+n0/cBDA16YSFhREaGkp8fDzJycnk5+dTVlZGRkbGgim9m81mLl68yNmzZxkbGxMT/PDwMHK5nPDwcLKysoiOjiYiIkKkUyWzz4SEBLRabcDGJ5m17ty5E41Gg91uF6mNhIQEIiIiiI6ORq/Xz/mu8fr165w7d46LFy8yODh4k6UNcMuvSZ+9y+Wivb2dmpoaDh06RH5+PlFRUfOWYh0bG6O9vZ1jx47R2tqK1WoVafLpxMTEEB8fT35+PmlpaRQXF7N06dIFc4u5n/B6vYyOjvLKK6/Q2dnJ8PAwDoeDsbExYfc2Pj4u0tXwiXWZVEMQHh5OQkICGo1mznbiXq+Xq1evYrFY0Ol0rFu3jrKyMuLj44mJiSEzM5OQkBB0Ot2CebLejoGBAa5du8aRI0dIT0/HaDQil8uRyWQiVTw0NMTExATj4+M0NjbS0dHByMgILpeL8PBwfD7frO/PhoYG3nnnHSYmJm7a5CQmJpKbm0tMTAxlZWWUlJSQlpYW0LnuRiYmJkQw7O7u5tq1a+I4zuPxYLPZsFgsjI6Oit2jZMQuk8nEggkQnp9S5uhOuWez4/Xr13P58mXhaCGTydBoNLfcRUnmt/Hx8RQUFFBQUMDKlSsJDQ1d0BW6yWTiyJEjXLt2Da/Xi1KpRKfTER4eLgJheXk5mZmZpKSkkJycTGJiYkCLh6SzPbfbjVKpJDs7m8ceewy9Xs/Y2BhOpxO/309CQgJhYWEBM/w0mUxcv36dlpaWWwbBO8FisVBXV8fbb7/Nnj17WLx48bwER4fDQWdnJ/X19Zw/fx673Y5cLker1YqzGrlcjk6nIzs7m6KiInbt2kVeXh5xcXH33YS6UDidTrq6uvjxj39MV1fXTa9Lk5BkYA5Tuw2NRkN4eDgymYz4+HiKiooICQmZswWH1+ultbWViYkJYST86KOPEh4ePiffP1CMj4/T0tLC0aNH+dd//VcKCgpYtGiRuC5Wq5Wmpia6u7vx+Xzi+mo0GnQ6HQaDgfT0dFJSUsjKyrqnudPv92O1Wrl8+bIwd4dP0qcREREsWbKEbdu2kZKSQklJCZmZmXN2DT4LKfvQ1dXFxYsXOXXqFA0NDTQ2Ns44/ridr6302vQ5y+/309XVhcPhuKux3PPOcfny5aSkpKBQKPB6vYSHh7Nx40b+/d///ab3a7Va8dBI//9+SFu1tLTw3nvv4fF40Gq1xMfH8+Uvf5lNmzaRnp5OcnIyGo1GjHU+xmy1Wunq6qKlpQWj0UhmZibx8fG8++67XLhwgdbWVsbHx9m9ezerVq1i48aNc1boMJ0dO3Ygl8v52c9+htvtvqe0rc/no729nZ///OecOHGCZ599lm984xtzPtbpuN1u9u/fz29/+1suXrwoDKylB12j0Yi0/iOPPEJSUpLwF70f7sn7CbPZzH/8x3/ccsWtVCoxGAykpaWRn5/P2rVrAYiOjiY+Pp6ysrIZz00gduJKpZK4uDi2bt0aMHf6ueSnP/0px48f5+TJk7hcLmpra7l06dKMwiDpOVOr1eh0OtLT09m2bRuLFi0iMjKSTZs2ifT03V5Tr9eLzWbjG9/4BtXV1TNeMxgMLFu2jJdffpmMjIwFMbGGqQX12bNn+Zd/+RdaW1sZGBgA7v3YSKvVEhMTw/bt2+/aqHlWpZZe0ubGAAAgAElEQVQGg4GYmBjMZjNOp5PR0VEGBwfJyMiYcbYg5fzvt8mnrKyMf/qnf+KZZ57BYDCQkZHBE088QUxMDCEhIWKnMZ/U1tZSWVmJw+EgJSWFzs5Ovv3tb3Py5ElxLioVytTU1NDc3MxTTz0157tZm82GzWa7aYUWFhbGnj17KCoqmlFg4fV6OXToENHR0ajVag4fPszg4CA+n09ULEpVt4FESrFYLBb6+/sB2LNnD2vXrmXLli2iuECtVpOcnIxWq0WpVN539+b9QFhYGCUlJbz11lvA1OcfERHB2rVrKSwspLCwkMTERCIjI4mKigI+2TkGymh7fHwcs9lMe3s7arWa+Ph4EhIS7mtjb6lgpKamhqamJpxOJ5GRkeKooa2tTbxXLpezbNkykpKSRDFbXFwcer0etVpNRETEPd+vnZ2dvPXWW1y8eFEEHZgyoF+yZAlf//rXSUhIWLBCNLvdTmNjI7/4xS9obm5mbGzstkExLCyMqKgoent78Xg8M94XGRlJbm4uERERZGdnU1BQQHl5OUlJSXc1nlndUQkJCRQVFYlDUavVypUrV9BoNERGRqLT6XA6nSJHfqt01UKtUADi4+NZsWIFMpmM0NBQkpKSyMvLm/dxTKelpYVr167h8Xhwu93i3K6zs5PY2FjS0tIwGAxYLBa6uro4cuQIW7ZsISkpCYPBMGfj6OzsxGQyzThPUiqVpKeni0P66Qf0Xq8Xn8+H0WgU+f66ujo8Hg9RUVEUFxcHvCJZqjbu7u7GarUik8koLi5my5YtrF69mhUrVgTPEu8CnU7HokWLxEJXLpcTGhpKSUkJmzZtorCwkMjIyHkNTKOjo+LsKSUlhejo6Pt61ygVfkmmwgMDA0xOTpKVlcWaNWtIS0ujublZvF+q50hOTiYhIYGsrKw5G8vY2Bi1tbUMDg4yMTEBgF6vp7CwkPXr17NmzZoFvZZms5mGhgaqqqqwWq1i7gkJCSEqKkpkd0JCQoiNjSUxMVEc+0iVvDBVR7B8+XKio6PJysoiLy/vnq7jrO7qLVu2EB0dzdGjR/F6vbS3t/P973+fBx54gMWLF5OdnU1HRwejo6PodDq2bNly0/dQq9Wo1eoFWfmNj4+LCqfU1FRycnLmfQw3Ul9fT01NDQBnzpwBph6Y3NxcnnzySXbu3ElxcTEffPABBw4c4OWXX2b9+vVs3bqVpUuXztk4Dh06xJEjR8RDBFOf1a5du1i/fv0tK1CfeeYZ8fd9+/bx2muvMTExQW5uLqtWrQpI+nc6Xq+XsbEx3n77bUwmE6mpqbz44ousWLFiwc+3P4+EhISQnZ0tnk2ZTIbBYKC0tJTy8vIFGZPZbObSpUu4XC4xQd7POBwOTCYT77zzDi0tLYyMjKDRaPjSl74075XcUoGVFEiUSiWpqak89NBDbN26dV4yO5/Gxx9/zOHDh+nu7hZfUyqVJCcns3PnTvLz89FqteTm5pKUlERycjJNTU14PJ4ZRUUGg4GkpKRZFxDNKiLpdDpRgTg+Po7dbqeurg6TyYRarRZNt9LO8VarkrS0NAoKCvizP/szkpKS5lUpp7Ozk48//pjJyUkKCgrEuclC4HQ62b9/P5cvXxY9YhEREWRmZrJy5UqefvppkpKSRNHBpk2bGBsb48033+Ttt98mJiaGgoKCgAYgl8vFO++8Q1VV1U2FNWq1mkcffZRFixaJHeXatWtRqVRERUUFPDACoqAqNTVVqN68+eabYgcUGxsb3Dn+DhEbG3vX50jzzaVLlzhx4gQ/+tGPGBkZITk5mWXLlvHoo48SExMzr2ORzt7Onz8veidbW1v5r//6L2w2G1//+tfndTw30tHRQUdHh/i3QqEgNDSUZ599lrVr15KamopMJhObKZlMRmZm5gyBBPikuGi2zOo7SAo3RUVF1NXVMTIyIsr475SRkREsFguxsbGsXr2azMzMeauOcrlcDA8P4/f7sVgsXL9+HZlMxtKlSwkPD5/X3LtMJkOv15OVlYXH40GhUFBUVERmZiYFBQXk5OSg1WrFmPR6PcnJySxfvpzGxkahFhIXFxewMUoKOaOjozcFO7lcjkqlIj4+XlTQSq07hYWFZGRkzBh/IJAeEul82263c/HiRdRqNVlZWeTm5oqKY+mMLMjni5GRETo7O5mcnBSylfcjPp+PtrY2Tp06xZkzZ8SCV6qU7u/vZ2RkRNRjzEerREREBKtWrWLHjh3U1tbS2NiIy+Xi2rVrqFQqMjIyiI2NJTY2lvj4+HlZ0MLUc+t0OoW6koRWqyUiIgKVSkVfXx8ymYz8/PwZc8hc9M3ejlkHx7i4OMrLy7FarbjdbtHnNh2FQiF+IUkKSXqPdEG6urowm82Ul5eTnJw8Lx+M1+sVgfz69etMTExw4cIF/uzP/oysrCwMBkNAL/50lEolOTk5bN68mby8PNRqNQ888ADx8fG3PUs0Go1s2bKF8+fP093dTW9v75wFR5VKhVarxWAw4PF4RAZgdHRUNCPfyPRVnzS+/Px89u7dywMPPEBMTExAr6lUjKNSqVAoFLhcLq5evUp9fT2pqamUlJSwZs0aNm7cOO+LnyBzQ29vL9euXQOmmuFjY2MZHx8XQUeqjJ0usSbNNTKZbIY8WiA/f5fLRWVlJR9++OGMylCXy4XVauX06dNid6NSqdi+fXvA+6YjIiJYs2aNECDo6enB6XTS3NwsepmXLFnCkiVLWL16NWFhYajVahHAA5V1mZycZGxs7JbBMSwsjK6uLtra2kQldEhIyAxhh0DVrMg+o0T2jupnPR4PH3/8Mc3NzfT09FBRUSF6y2QyGWVlZeJAVNLgvHDhAjAVHIeHhxkfH8doNFJQUMAjjzzCY489NqcFJrdi//79/OhHP+Lo0aP4/X5xoQsKCli2bBl79uxh79698yZSIC0apM/ks6rSent7uXDhAk8++SQrV67kgQce4JlnnpmTG6W1tZXBwUEGBgZ45513qKmp4erVq3f1PaTJSalUsmLFCkpLS1m1ahUPP/xwwM7/pBX7Sy+9RGVlJQBZWVmix6yjo4Mnn3yShx9+mLKysnv9MZ/Xw8u7qod3u90MDQ2xbt06TCaTWMC98MIL7N27N1BjvC02m40XXniBF198EY/HQ0hIiDh6SE9PJyEhgaSkJFJTU4mMjCQsLIzY2FgaGhqYnJwkIiICm82GTCZDp9OJ/su5DpIul4uenh4ef/xxGhsbsVqt4rXpz8R0srOzefDBB/nOd74zp2O5FV6vF4vFQnt7O9/5zneoqamhv79fzDdhYWHExcURFxfHjh07WLlyJQkJCaSlpQXk2EuqV/lv/+2/cerUqRmvTd9YhYSEsGTJElasWEF8fDxGo5H169cTGRk5o9f2Hrjl8zwnVTAqlYri4mIyMjKw2+2UlZWJSiOpEVg6K3O5XKJPD2BwcJC2tjZ+9KMfMT4+zvXr13nttddYv349aWlpAT0kTkhIYN26dajVanFGJZWKOxwOBgcHWblyJUajcV4CpEwmu6tc+fT+MUk8YK4wGo1ERESQkpJCVFQUOTk5REdH09raisVimVGoczukYO/z+WhoaBBC5Dt37kSv1wekCEuhUJCYmMhjjz3G5s2bgSmVFrvdTnd3N0ePHmVwcJDXX38dr9fLsmXLAiL/97vA6OgolZWVQpXJ5/NhsVi4fPmyKIZJSEiYt+yKSqUiKyuLDRs2MDw8TH9/P263m+7ubgYHB0WzvE6nm9FbLamoaDQa3G63qHjctWsXO3bsIDk5ec4Wa263mzNnznDo0CFaW1ux2+0zXp/+TEj/hqn6h/Pnz/P666/zhS98IaA7SKVSKaqMv/rVr3L9+nVMJhMNDQ10dHQwMTFBT08PFosFm81GRUUFiYmJlJaWkp2dzeLFi4mKiprzBe6tNmo3Xqvr168zNDREVFQUMTExHDhwQByZ7Ny5k/Dw8Dm7H+dsdoqPjyc+Pv6u/9/IyIgQ9e7q6qK/v18oRRgMhoAGR6PRyMqVK4mMjKS9vZ2+vj6Gh4epq6ujt7eX/v5+TCYTISEhCyZxt1AYDAaxc09KShIuBmFhYaIC+VZ4PB5cLhcWi2XG14eGhmhvbyc8PJzh4WFcLpdIm3wWkmLQdBHkT0Ov19+k1+t0OsUZz+HDh7l48SKZmZkB08b9XcDlctHb2yuqG/1+P6Ojo9TW1qJQKMjOziYvL4+IiAj0ej1hYWEB7WeWFKO2bNnCwMAA7e3t4j50OByi11rqb5XGPL3B3uFw4HA4xKIyPj4emUxGUlLSnIx7ZGSES5cu8cEHH8xQdFEoFISFhaHT6dBoNISGhgoxf5PJxNjYGM3NzRw4cID169cTFxcX0DlHrVYTFRVFeXk5WVlZdHV1kZiYSH19Pb29vWKD0NDQwJUrV4iNjaW/v5/Fixfj9XrJyckhMjJyzhSvpBSpJCpzK9xuNwMDAwwMDAh3pJ6eHvLz81m2bJlQYJPaCGfLgnfORkREkJOTw6OPPsovfvEL2tvbcbvdovE4NTU1YD87JSWFlJQUdu7cCXxyMPz3f//3nDx5kitXrvDhhx+iUCjmvbLsbpne5xMIVq1aRWlpKU1NTZhMptsGx56eHpqamvjJT35y02smkwm73U59fT3Dw8NERETckafe6Ogo7e3tGAyGe5Z3kxSQHn/8cQYGBjCZTFy5coU9e/bc9ff6fSEsLIzS0tIZk7TT6eSdd97h/fffR6/Xk5OTQ1FRERs2bGDPnj2Eh4cHrF5AqVRSVlZ223T48PAwZrMZs9k8w7VBCno+n4/z589TVVVFXV0d77zzDk1NTWzdupV/+qd/mrXoh9/vp6qqiosXL3L9+nXgk2yQVqtl7969FBUVsXjxYrZu3UpHRweVlZX8yZ/8CR6PB5PJRE9PD+Xl5axfvz7gPdeSqENERISQUARobm7m7NmzmEwmDhw4wMWLF+np6eH999/n8OHD/Pu//ztf/OIX+eIXv8iOHTvmZBwGg4Hw8HAMBsMtNZBvZHx8XGip1tfX09TUxMmTJ/mrv/orysrKWLZs2azHteDBUWL6Ten3+zGZTMKfaz7HoNVq2bhxI+Pj41y9ehWdTjdvaaPZMB8tCgqFgoyMDBITE2+bwpVWw48//jg/+clPqKqqorGxUbw+NjbG888/z7e+9S3WrVt3Rz+3v7+fjz76iEuXLvHlL3+ZP/iDP7jn30GpVGI0GjEajZw6dYotW7agVquFLViQT9BqtaSkpBAfH8/o6KiQ4oOpQGO320VK7uzZs7jdbnJzc0lJSZlXPU6J8PBw0cpzO5YtW4bVaqWtrY1vfOMbdHd3U11dzZkzZ1i/fv2s0pkymUxUZkdGRuLz+SgvL2fFihXs2rVLnI3pdDoUCgXJycmsWrWKP/qjP+LDDz+kv79/3gRRrFar2IXl5+fPWPxLZ7Zut5uHHnpIpIY/+OADLl++TG1tLe+//z4nT54kKSmJP//zP2f16tX33FYjmTzs27ePjIwMurq6CA0NZWBgALPZTEZGhkjxwtRuv7e3V1hUwdS55cDAAC+99BIXL17kj//4j9m4ceOsdt/3ZXCEqRXqjVZX8zWO9PR0EhMThanq3bSm3A1+v5+hoSEUCgVarfa+VvqQ0Gq1nzmB+P1+UlJSuHr1qpCEkpAKZlQq1R3vAG02G01NTVy5coW1a9cyNjZ2z4Lrkpm10+lkYGAAq9V607lQkCkUCgXh4eFs3ryZuLg4kf7zeDx4PB4sFgt2ux273Y7VahUOKBkZGTz44IPExMTMWzuANF7pzPF2hIeHixqIJUuWUF1dzdDQENevX2flypWzPuuLjo5m+fLl7Nu3D6fTSVlZGcXFxSxfvvym90rp1ejo6HmXMGxpaeHMmTP4/X6MRuOM4KjRaERQmS6y4HA4iI2NJSwsjEOHDtHe3k5vby+1tbXk5eXdc3CUBNaLi4tF+lZSARsYGCA5ORmr1SqEw6Oiouju7iYmJobr168zMjIibNM6OjpQqVSkpaXN2gR+ToLjpymkfx5JTk7GaDTi8/no7u6esWKeK6RJ+urVq6If8F6CYyB8HGeLdLOXlZUxNjbGu+++K16TvB/vRozabrfT0dHB8PAw3d3dtLe3U1RUdE/nW1KlXnd3Nw6H4yZ1jSCfoFAoMBgMfPOb3+TKlSucO3eOxsZG7HY7FouF6upq0T7j9Xr57W9/K3abiYmJrF279r48jlAoFERGRrJv3z7RHyxlJWaD3+/HYDCwd+9etm7dyujoqNBpvt37JU/Z6e0mgdah9vl8VFRU8OKLL4rqzztRB9uwYQNLly5l3bp1NDQ00NLSgsPhoKqqSqRk7xWFQsHSpUvvWOVraGiIhoYG/t//+39cvnwZk8kETGWuOjo6eO+993jmmWdm5Vo06+Dodru5cuUKExMThIWFzamE2UKh1WqF/1xKSkpAbJZGRkaoq6vjmWee4YknnuBv/uZv7vp7SPYugBDTvp945513OHr06E1fn5ycFCmdO+nLLCgo4G//9m/5t3/7N44fP86xY8d46qmn2L17N6mpqXdc9er3++nu7qahoUGcCQX5bIxGI5s3b6asrEyIfExMTNDZ2cnAwAAVFRX86le/Ynh4GKfTSU9PDz/84Q9FX+t8+gDeKXq9nieeeILTp0/T2NiIwWCY1dGEzWbDZDIRFxeHwWAQ/rWf9j0rKys5ceIEv/rVr3C73YSHh5Oeni6KS+YaKRi/+uqrnDhx4p6OrSTFq5KSEtEjuRBER0ezatUqXnrpJX7wgx/wxhtvCDNzl8tFf38/Q0NDhIWF3XNGblbBUUqt/PrXv2Z4eFjYVklVawqFgoKCAgwGw23NTsfGxjCbzbS1tc3w27qTqsRAUVVVxfXr19FqtZSWlt61mvtnMTExwfXr1/nZz37G0qVLZ3i63Q3SxCSpWyxZsuS+2rlLzfg34vP5GB4exmKx3FFwDAsLo6CggFWrVnH8+HHhERkTE8Pk5KRwe78dUvVsR0cHr732GlVVVahUKvLy8sT5SpDbIzWAS2fver2e0NBQ9Ho9KSkpoqjj5z//OUNDQzidThoaGoTA9f0YHKX6AqVSic/nw2azzaqorbW1lR/84AdkZ2eLRvro6OhbqkL5/X7MZjMnT57k8OHDOJ1OoSG6Z88eEhISAtJPKBm5Hzx4kLq6urvOOlmtVhoaGti/fz81NTUznD1mi8/no66uDqvVilwu/8wUtyTi0NPTw9jY2C2zP5KAwb0yJ8Hx/fffF+W1AwMDGI1GsZPx+XzExcXdNoKbzWYaGxtpamoSwVEmkxEbGxtwEYBb4fF4qKyspL6+npCQEBYvXjzn+o1S+8p7773HCy+8QH5+/l1/D4fDQXd3N2fOnEGj0ZCenk5hYeGcjlNC6qGUnFc+bbHj9XqFU7fUUyYhVe5FRUWJyuA7QafTkZSUxMqVK+ns7KSlpYVTp05RWFiIXC5Ho9EQFRUlVDOkHbS0Uh4aGqKxsZGKigr+8z//E6fTSXh4OCtWrCA9PT0YHO8S6ZprNBqio6OJi4tj0aJFHDt2TDjYm81mRkdH7/gzXghcLhcej4fJyclZLyq7u7v59a9/TU5ODj09PXg8HhYtWiTcJKRgNzk5Kbwcz5w5w/nz54GpzUBSUhLbt28nKioqIEWAkvD4uXPnMJvNaDQa0eJktVpvm4Hx+XyMjIyI+ebVV1+lr68Pr9eLRqOZdaX85OQkNpuNc+fO0dXVRVhYGEuWLJkRHKX0vXTe7fF4sNvtXLhwga6urhn3mVqtngthgNkFR0l+zWaz4fF46O/v580335xxo7344oukpqaKhuEb6ejoEOkZmEoPajQa/u7v/m7e7aNcLhetra289957mEwmkpOT7/ks8NOoq6ujoaEBlUrFAw88cE/OAqdOneLIkSNUVVVRUlJCfHx8wCb50dFR+vr6aG5u5n/9r//FY489xqpVq265o+7q6qKhoYGXXnqJzs7OGcUuGo2G+Ph4/vmf/5l169bd1e8tl8vZunUrycnJrFmzhmeffZaf/vSnvP766xQXF/O1r32N2NhYQkJCWLlyJTKZTPRpffTRR5w+fZoPP/xQnAulpaXxla98hby8vPveQf5+R6fTER8fj1ar/dwIu7tcLi5cuEBHRwdarZYnn3xyVotxnU5HcnIyzc3NXL9+nf/4j/8gKyuLjIwMsrOz2b59OzB1VtbW1sb3vvc97Ha76OkzGAykp6ezYcOGOfn9Pg1px+hyuThx4gQajYaTJ0+SlpY2o/VFor+/n+eff/4mQ+YbBb/vFZfLxalTp3j55ZcZGxvjy1/+Mk6nE6/Xi1KpxO1243Q6GRsbo6WlhcbGRurq6qioqKC5uRmXyzVj55iWlsZTTz1FRETErO7HWQVHSfz6K1/5CtXV1XR0dNDV1TVjoD6fj97eXoaHh2lpabnpe0jNu/BJv0tmZiYJCQmz3jn29PTw4YcfcvLkSVasWMHmzZtFmbdSqZyh8VpfX8+VK1d4++23aW1tpbi4mGeffTYgIgRXrlxhcHCQ3bt333X6xO1209nZyXvvvUdVVRXh4eE88cQTc9LXcyv8fj/79++nsrKSCxcu0NbWxiuvvMLbb799y7SH0+lkfHyczs5OcYPD1L1SVlbGjh07KCsru+dAHh0dTU5ODuvWrePy5cuimOKFF14Qu5klS5Ygl8txOBy0tLTQ29uLxWLB7/ejVCopLy9nx44dFBUVLbhNz+eJyclJent72b9/P0NDQzz99NMoFAq6urqorKykoaHhjnrUFpre3l4aGhp48cUXsVgsFBQUkJ6ePqtdRnJyMo8//jg//OEPRUVvZ2cng4OD1NXVcfr0aWAqMzUxMcHExAQ+nw+NRkNCQgLbt28PuA2YXC5Hq9USGxsrzMwBampqaGxsJCQkROwCpwcVl8t1yyCYnJxMdnY2Tz311Kz60e12O7/97W/p7e1lbGyMN954A0Ckl2tqauju7mZkZERUR4+PjwsxEZ/Ph0KhICIigvXr17Ny5Up27dq1sJZVUqn3pk2bhLRYXV0ddrud0dFRIcfmdDqFesWnER0dTUZGBps2bSI8PHzW8mKTk5N0dHRw+vRpYZ4pfYharRafzyfaRerq6qivr6eiooLU1FQWL17MmjVrApLe6O/vx+fzCem6z/odvF6vSIkMDAxQWVnJlStXsNlsLFmyhFWrVgXU166zs5P6+npqa2sB7qp6V6FQoFQqKSwsZO3atZSVlc2q2ECv15OUlMSmTZvQarWYTCZ6e3vp6OjA6XSKCVwmk+F2u+nr68PlcqFUKgkLCyM9PZ2VK1eyatWqoDLOXSA9v01NTZw5c4bOzk4WLVqEUqkUfY4WiwWXyyXk2WZ75vNpOBwOkbGSkBRWLBaLmOQnJyeRy+V4vV7cbjdKpZLW1lbq6+tpbGwkLy+P0tJSIiMjZ7XLiI6OpqysTGwSLBYLg4ODolFdqqacTnh4OEajkbVr1wrz6ECiUCjQ6/XC4L25uRmn08nQ0JBwDZkuzC4h7SaVSiV6vV5k03Jzc1myZAnLly+fdfZF+v4ul4uWlhZOnDhBTEwMWq2W2tpaenp6Zsw704O1Wq3GYDCwfv16tmzZQnFxMenp6bO+92ZdrarVatm9eze7d+/GarVy+fJlOjs7uXDhAidOnKCxsVE4cXwaMpmMZcuWsWPHDp577rnZDguY8i+Li4tDp9Nx8OBBDhw4IH5WeHg4Xq9X3LzS1wG++MUvsnXr1oClKW02G1qtli1btszow7nVNXI4HIyOjjI+Ps758+eprKzkl7/8JUqlkpKSEp5++mmWLVt2X8rbKZVK1Go1oaGhfP3rX2f16tXk5ubO6nuGhISQmprKc889R01NDfX19Zw5c4b6+no6Ozvp6uq6ZYYiNDSU9PR0vv71r1NaWjqnDuu/D/T19XH16lXOnj3LpUuXaGhooLa2FplMhsfjmXHmo9FoSE5OnjMZrxuRrNMuX74sJNr8fj8hISEYDAaOHTsmdhTSxG632xkYGCAsLAyTyUR/fz9paWl885vfZPXq1bPOUsXExLB161ZSUlI4fvw4hw8f5uDBg5/aJlRYWMiGDRv467/+a8LCwgJegKhSqYiJieFv/uZveOONN3j11Vfp7OwUjjs3Mn2xMDk5iUajIS8vjy9/+ctkZWWRl5c3J2IPBoOBP/7jP6azs1P0HVdUVNzR/5XL5ej1enJzc/nnf/5nUlJS5uyemxNXDgmptUAKOkNDQxw/fpzW1lZ6enro6uoSO0sJSTR2/fr1bNy4kfT09DkrY/b7/XR2dnLt2jV++tOfUllZKXzBpEA4/TA5IiKCTZs28T/+x/8gLy8vIC0cAF/72tdoamoiOzub0tJS1Gq1sG25du0aNpuNpKQk7HY7fX19tLW14XK5RN/ZsmXL2L59O9nZ2WRkZBASEhKwKlW/38/zzz/PkSNH7viGldi3bx/l5eXs27ePqKgoNBrNnO7E3W63OI8YHx+ntbWVa9eucf369Rkr4O3bt5OUlERUVJTQrFSpVLO5ZvdPSfDdcc8HRB9//DG//vWvef/9929ZbCVd75ycHEpKSvj2t78tdhhzfW9KJr11dXV0dXXR1dVFdXU1/f39jI+PU1paSmNjI729vfh8PqKjo0UxWWlpqagm3b59O7GxsbOWjZuOlDa12Wz09vaKr/v9fg4fPozb7SYiIoK1a9cKcf/Zno3dLdL8bLFY+OCDD+jv76etrY3f/va3+P1+wsPDSUpKYt++fTOe17i4ODIzM0VGTaVSzYl5gFSc9/bbb/Pxxx/zxhtv3DaVKxX0SY4sW7ZsYcWKFRQVFZGdnX2vYgqBc+WQkHLaMLXCl3ZneXl5jIyMiCZuqTcPpi640WgkJyeHzMzMOS2OkKpeFy9ezMMPP0xhYSFms5m+vj7a29uFskJcXBwxMTGkp6fz4IMPkpaWFlC1ms2bN2M0GtSfYFUAACAASURBVOnq6qK2tlb0VTqdTqxWKy6Xi4GBAdxuNwqFgszMTJKSkoiMjBQOGYWFhURHR8/LmVleXh6jo6PIZDIqKio+MwsgrTA3b97MmjVrAqaPq1arRUolIiICnU5HTEwM2dnZM8ZYVFQkpMU+D1KA9yN6vR6j0Thj8pGusVqtJiQkhJycHEpLS1m5cqXoPw3Eok0ul4vnIC4ujoyMDFJTUxkdHcXhcJCTkyPMhCcnJzEYDExOTuJ0OklLSyMtLY3U1FSSk5PnPCipVCrCwsLEPTn9PpQqvkNCQsjKypp1NeW9olQqiYiIwGAwsGHDBsbGxhgcHCQtLQ2YKi6KjIykpKRkxm42NDRUWIHNJZKFmKQi1NfXJ6pnVSoV7e3twnHFaDRSUlIishLSeXF8fPycX8s53Tne74yMjNDf3091dTXHjx/HZDIxMDBAUVERhYWFFBYW8sADDwR8FedyuWhoaOA3v/kNDQ0NwvH6Vkhl8hs2bCAmJmZBCkhaW1tpb2+nvr6e//t//+9nKspERESwb98+vvrVr5KRkfG7GJB+73aObW1tVFdX82//9m90dnbOOP+RAueePXtYu3YtixcvnjPT7SC/X5jNZg4dOoTZbCYkJAS9Xs9HH31EeHg4MTEx5OXl8YUvfIGoqKi5/LG3fJ5/r4IjfNIvI52D+v3+GQ7i85XeuNHY+HZMdzRfqAZ/6TpJknd3glQccT+JEswhn9df6p6f5+mf/63u2enPz+elnSPI/cn0s2L45OhLmgsDcDYbDI5BgswRv3fBMUiQ32Fu+TwHl3hBggQJEiTIDQSDY5AgQYIECXIDweAYJEiQIEGC3EAwOAYJEiRIkCA3EAyOQYIECRIkyA0Eg2OQIEGCBAlyA3OqkPN5xu1209vby69+9Ss8Hg/Z2dns3r2byMjI39VevSBBggQJchvmJThKZrkOh4Ph4WE8Ho9Q7g8LC0Ov1y94AHK73fT09PDKK6/gcDhYu3YtaWlpZGdno9PpUKvV6HQ6oQ4TaJHgG/F4PMKyZboTgUwmIyYmRogEqNVqVCpVsBE7SJAgv/O43W7sdruwAYMpCT+9Xk90dPTC+TneKTabjf7+fiorK/nf//t/09HRgVqtZseOHXzlK19h165dAdUyvRMkM83h4WHGx8f58MMPqaioYN++fSxbtoyioiLWrFnDwMAAMpnslsbNgcLv99PV1cUPf/hD3n//fTo6OsRrKpWKf/mXfyEsLAyVSkVBQQGLFi0KmGh6kCBBgtwP+Hw+mpqaOHjwIMeOHePw4cMApKens2fPHr797W/Pylkp4MHRbrfzzjvvcOrUKS5cuCBcMSYnJ7l69Spms5mJiYkFD459fX10d3cTGRlJZGSkEAn+8MMPOXXqFKGhoURHR7N48WJKS0t55JFHAj4mj8dDY2MjlZWVHD9+nEuXLtHf3z/jPT6fjx/96EcoFArUajVpaWk899xzLF++fNY2PO3t7bz11lucPHkSt9uNXq9n+/btyOVyRkZGOH/+vLAFS05OZmxsDIvFwtDQEO3t7aSlpZGbm8umTZsoKipCq9XO247b6/XicDgYGBgAYGBggKamJmF029nZeUvX87S0NBYvXsxf/MVfBHffQe4Zp9PJ/v37OXjwIF1dXYSGhrJ+/Xry8vIoKCggLCwMr9eLxWLh/fff5/z584yMjKBSqfjXf/1XkpOT511H2e/3MzExgdlsprGxkb6+Pvx+P263m7a2NjIyMsjLy6O8vHze9ZK9Xq/wnjx37hx9fX1YLBaOHz9Of38/w8PD4r12u52mpiYcDsesrMACFhwnJydxuVycP3+eM2fOUFlZSUtLi3Bt1mg0ZGZmEhUVNSe2J/eK3+9naGiI1tZWuru7KSoqIi4uDplMxsTEBN3d3fh8PuRyOS6Xa4bFVaBpaWnh4sWLHDlyhKqqKuF8faPPWnNzs0ip+nw+bDbbZ4qDfxYul4ve3l5Onz7NiRMncLvdwidNJpNhs9moqqoiMjKSuLg4EhMTsdlsWCwWrFYrJpOJlJQUTCYTTqcTvV5PcnJywAyG7XY7DoeDiYkJ+vr6sNvt2Gw2YTI7ODhIS0sLfX19NDc3093dDUwZzmq1WmE6rVarSU9P/0zN298nXC4XXq8Xj8eD2+2+yWlC8hyFqQWdz+cT7jxqtZqoqCiio6MDmu53u93I5XIxlzgcDpxOpziC8Hg8OBwOxsbGmJiYwOl04nA4MBgMxMbGUlRUNKfj8fl8dHd3U1VVxfXr1zEYDExMTNDR0UFHRwcGgwGfz8fw8DBHjx6lqqqK8fFxtFotg4OD82YyIJlG2+12hoeH6ejooLOzk+bmZgYHB8UmwWQykZqaSk9Pj3DQmEurr0/DbrfT0NBAV1cX3d3dwp7MarVSXV0t9J6lsTidTrq6uoR4+b3OOQGLSh6Ph6GhIb773e9y5coVYUoKU5YpkZGR/OVf/iXFxcUL6sju9Xqprq7mxIkT9PT08Oijj7J9+3ZCQ0Ox2Ww0NDTMENvW6/VzrQh/S/x+P++++y5Hjx7lxIkTYpcjTS5yuVyIpktu50qlkoSEBAwGw6xXdiMjI5hMJmpqaoRHp81m47333pvxQIyNjc1I80qvyWQyuru76erqoqKigpiYGDZu3BiQz3pychKTyUR3dzft7e3s37+foaEhLBYLra2tM8YmrSKl65OdnU1CQgIxMTEA5OfnU1JSEtw18olI/8DAADabTRyPTA+ODocDk8lEbW0tMHXfOJ1O4uPjkclkxMXFsWrVKsrLy+fc/Hi6ifrQ0BBarVZY3vX09NDb28vIyIgYV2dnJ3V1dbS3t2M2m+nq6iI/P5+dO3fyve99b87GNR2ZTIbP52NsbIyPPvqIjz76SLw23XMUpqzeQkNDGRsbw+FwBGQ803+21+ult7eXa9eu0dLSwoULFzh48KCwp7uRq1evUlVVxdWrV/nxj39MfHx8wE3WpUXGj3/8Y44cOUJPT89n/p/x8XHa2tqoqqr6VMejzyJgwXFgYIDa2lrOnz8vDkoBIiMjWbduHU8++SQbNmwIiFP4nTIxMUF/fz+vv/46zc3NREREsG7dOsLDw1Gr1Wg0GlavXj1jMpgeoAJFf38/+/fv55e//KXY4cAnB80FBQVs27YNu93O2bNnhQt6YmIi//AP/0B8fPysr2tsbCyJiYlERUVhsVju2I1jvjGZTLz11lv87Gc/w2Kx4HK5cDqdwnkFpq6b0WiksLCQ73znOxgMBhEkJY9HKVgqlUrUavWCF4gtNDabjcuXL/ODH/yAq1evMjExIXaP05Gus8vlApjhdANT1/PVV1+luLiYbdu2sWvXLoqLi2d1fSVz3Oeff57Tp09jtVpxOp0oFArxOdrtdlwuFy6XC5lMJoKBtLNVq9Xs3LmTr33ta8JHcCHQaDRkZGQQFRVFYmIihYWFrFmzZs49E6czPj7OmTNnOHz4MO+99x52u12YHKemppKWlkZxcTHJyckzPqd3332Xzs5Orl69yq9+9Ss2bNjA8uXLA7bDlQzgX3jhBU6fPn3TkdKt0Gg0ZGVlsW/fPhYtWjSr6xiQ4Njb28vFixc5cOAADodjRipy+/btbNiwgZKSEkJCQhZ0hS7lsJuamkhMTKS4uJiYmBjhEi+lKucblUpFdHQ0wIz0qEajITk5mT/90z8lNzcXj8dDfn4+fr8flUolHLznYnKXy+UoFIpbfj46nQ69Xk9iYiIAVquVvr4+UlNTGRoaEim2tLQ0QkND0el05OTkBGTHrdFoSExMpKysjImJCVwuF0eOHGFiYgK9Xs+aNWswGo0kJydTUFBATk4OGo1GXB/JVuv3PRjeSGtrK7W1tVRVVdHX1yeOQm58HqRVudvtJjY2Fq1WKwKU2+1mbGyMvr4+WltbUSgUjI6OkpCQQGRk5KyeLY/HQ0dHB9euXROTO3xSRS4FQmnuke7ntLQ0MjIyhEdqcXExsbGx9zyOO0F6Nrdu3YrX66Wnp0fUMERFRZGWlkZkZCQRERHEx8fPWLwFgp6eHi5fvszJkyex2WwkJSWRkpLCsmXLiI2NFcck/x97Zx4V13ne/88Mw8wwwzLs68AgdoQQQgIhIUsCyZKt2PEiNY5j12naNG7SZj1N2jRNfo5zXOe0tZs4ceLGaR2ntZ04XhPLlmVrR7KEhFjEOuz7DDAwMwzMDLPc3x/KvQVtlgQD2OF7DudIcJn7cu/7vs/zPs/3+T46nW7O+g8PD5dO3F6vV2pgHyjj6HA4pDCqxWK5YqooNDQUuVwu7ZmFhYUUFBRQWVlJcnLyvCJVATGO/f39nD59mv379+Pz+aRwVnh4OJ/85CcpKyvDYDAE4tY3BJvNRldXFyaTiR07drBz585lwfJUq9VkZWWh1+uZnJxkdHQUj8eDUqkkLi6Offv2SY7F1q1bF318kZGRpKSkUFpaClw8vTU0NFBcXExdXZ1kHHNzc0lNTSUqKorVq1dLocuFRFhYGGvXriUtLQ2/38/k5CTnz59neHgYnU7HvffeS25uLnq9Xup0voJrw+/309zczLlz5yRmeXR0NCkpKZd54uI6djgcZGZmEhERIZHrHA4HJpOJCxcu0NHRQUdHBxaLhQcffBCNRjMv4yjm1m02m3SaFR0cpVKJXC5Ho9FI6QiFQoFaraakpIStW7eyceNG1q1bd9P3vxEEBwcTExPD5z73OdxuN3V1dSQmJpKRkUFycjJxcXEBN4izMTw8TEtLCw0NDWRlZbFlyxZKSkrYuXMncXFxV+WA5OfnY7PZ6O7u5sSJE/j9fhwOR0DGKAgCo6OjNDU10d7ezszMjPQzMdKjVCpJSUkhODgYjUZDRkYGd911F6tXryY7O3veYwiIcRwYGGBgYEBiCkZERJCXl8fjjz9OcXHxsjBAXq+XAwcO8L3vfY+tW7dSWVlJWVnZUg8LAI1Gw+rVq3n66af5/e9/z9NPP013dzdjY2M0Njbyox/9iM997nMkJycvyfg+9alPceedd3LLLbcASISM0dFRfvjDH9Le3g7Atm3bqKyspLi4OGALX6vVkpeXJ/3farWi1WpRKBRotVqKiorIz89fcjb0RwVijvHAgQMcPnwYgHXr1vGpT32Kv/zLv7yMAX3pifvS/4th1oGBAVwuF4IgkJKSMq+wv0wmQ6vVkpGRQUZGBq2trdL3lUola9euZdWqVXOcscjISDIzM7n33nsJCQlZ1EiBTCZDpVKRkZFBeno6e/bskb6/lBELjUbDN77xDSorKzEYDNcVxYuIiGDt2rUUFhYGdPwii/epp566LJRfUFBAUVER27dvp7KyUiLVLXRT+AU3joIg8N5779HY2CgNMiIigsTERDIzMyUW21LDZrNhs9lwOBzMzMwwMDAgLTKz2YzX60WhUGA0GiksLGTNmjXzLo24EchkMpKTk8nIyCA3N5eBgQG8Xi/T09McPnyYXbt2ERkZGfBNX9zcZpMHBEHAYrHw1ltvMTk5SWdnJ+fOncPtdtPW1iZd++KLL1JdXU1JSQmf+9zn5h1KuxpmL4ZL/73UG9BHDT6fj5GREUwmE+Pj46jVaj7zmc+wZcsWwsLC5jg5fr+fqampOWkTUYTi0tNHfHy8RKCZb0nP9PQ0L774ImfPnp1D0NDr9RQVFfG3f/u36HS6OXNNqVQSGhpKSEjIoqZyZq8dWHqDOBsul4vnn39eeh/XG1lZjL/B6XRitVoZHR29jDm+ceNGNmzYQEFBAdHR0VKkYKERsJyj1WqVBiwIAh6Ph5GREWZmZqTFEx8fv2QTpbe3VzKCo6Oj1NXVYbfbgYsxebHkpKmpCafTKRFhxBzVYkCkIUdHR0sTcmZmBqPRiNVqZWZmZklORGLOYmxsDIfDgdFo5MyZM5c9lwsXLkgRhIKCAgoLC0lNTV2UMapUKjQaDVqtdoV5egPweDwYjUbGxsbweDxotVqKi4uJj4+Xvifmdr1er7SmRYSFhREREUF2dvYcI7hQxDsx13Xw4EE6OzulNSveIyEhgcLCQkkUYynLxJYrwsPDiYmJISoqipqaGs6fP09cXBypqanLxnB7vV7cbvccMqcIj8fD5OQkw8PDGAyGq3Ij5ouAzJykpCR6enoYHh4GLm6mDoeDH/zgB2RlZREREUF4eDif//znl+wk+frrr3PmzBm8Xi9nzpzhzJkzV712eHiYwcFB/umf/omwsLAlXXBerxez2SyxBwONK52+fve73825ZnYx/aWLa2JigpMnT/Ltb3+bL3/5y3zhC18I+JgB4uLiWLVqFenp6UtCqvooQhAEJicneemllxgeHiYoKIjQ0FDi4uIYHR3l7NmzmM1mmpubGR4exul00tjYyNTUlPQZCQkJ5Ofn88QTTwREqclut9PV1cXrr79+2fy32Wy0t7dz5swZsrKySEhImJdCynwhrovlYnBEFBYWSkX0zz//PO+99x4zMzNScf9yG++l+K//+i/UajXx8fH84he/oKCgICCKZQu+y8tkMvbs2SOxycSF43A4OHLkCFVVVQQFBaFWqxkfH2fXrl2sX79+0RQXPB4PExMTnDp1ak4NHFwMvSQlJVFRUYHD4eDMmTMMDAxw4cIFJicnue+++8jOzg4ozfpSrF27lq985Su88cYbczaD4eFhRkZGAkJyCQTEony73b4oz09UDFopy7h+DA0NUVtby+HDh3E4HISGhpKens63vvUtzGYzvb29kiBGeHg4q1evJioqShJYsNlsWCwWzpw5w7333svXvvY1tmzZQnFx8YKNMTw8nNTUVFavXk13d/eck+PY2BjV1dV8+ctfJiwsjLCwMOLj48nPz5dqLLds2YJer5fY4IHCzMwM77//PiMjI/h8Pqanpzlw4ABut5uWlhbpOrlcjk6nY8uWLaxatQqDwRDwaFBQUBC33HILmZmZeDweqqurefnllzl16hTf+973KCoqWhaEyWtBFCn5h3/4Bx544AH27Nkzh3uwEAjIESg3N5ehoSEGBwc5dOiQVAvlcDgk9qpSqeTIkSPI5XKmpqakhRZoL18ul0tKMnCR0KHX60lKSiI+Ph6DwcD69euZnp4mPT2djo4O+vv7mZ6e5u233yYyMnJRjWNYWBhpaWnk5ubS1dUlbQZNTU0kJyeTn5+/aGO5GkT2ak5ODnK5XOpw0tLSIo13cnKS/v5+Ojo6FnSzvBo8Hg82m43Gxkb0ej1ut5vR0VFiY2MJCwtDrVavhFsvQXt7O8ePH8dms0mpkLGxMfr7+wkJCcFgMFBQUEBISAhhYWHSBmqz2RgcHKSrq4vW1lZ6e3vp7u6mtraW2NhYCgsLFyzaolAoiIiI4K677mJ4eFga38DAAA6Hg+npaaampiQ2Y39/P2azmdDQUFQqFQMDAxQVFVFQULDgqjizIZPJpCiTz+fDarXy/vvv43Q66e/vBy7mbIOCgtBqtYyMjJCZmUlhYSGVlZUBJw2FhoaSmprKnXfeyczMDOfPn6e5uZn9+/czPT1NWFgYUVFRS+ZYajQaEhMTyc/Px2q14nA4cLlcUghflLUT+Q4xMTFkZWUtaFQv6JFHHrnWz6/5w6shKipK8tzEk6JCoZgTZhAliSwWC6Ojo6SkpBAdHR3wMKtcLketVvOHP/xBkjWrrKxk79697N27lzvvvJPCwkJWr17Nxo0byc/PR61WS3mOHTt2LKpXJSrftLe3MzY2xtjYGH6/H4/HQ1hYGLfcckvANvm+vj7efvvty2qMgoKCpLo3tVpNdnY2O3fu5Etf+hKVlZWUlpai0Whobm6WyjqcTic6nY7w8HDWr18fsEUnkgwcDgderxelUolOp6Ovr4+TJ09K9xUXkchuu8HxfH/hR74oeORqP/D5fPz+97/nhRdeYGxsDLjoYFgsFjweDwUFBezbt4/vfOc77Nmzh8rKStavX09xcTGbNm1ix44dpKamYrPZ6O/vx+FwSKzSsrKyObWl84VSqSQ3N5fy8nKKiooICQmRah29Xq90HzE/KSontbe3c/r0aWw2G0FBQWzcuDFg89Dr9dLa2kpHRwcjIyM4nU7a29vp6+ubE0WxWq2YzWbq6upobW3FbDazZcsWQkJCAp6+USgUrF69GpfLxfT0NM3NzbS2tuL3+8nNzSU6OnpRORaXjs3pdEqCDTBXYEJcty6XC7fbjdPp5NZbb71ZicIrr+fZbMQrfN00/H6/4PF4BIfDIbS3twvvvPOO8OCDDwrbt28XsrKyBJlMJshkMkGhUAhRUVHCF7/4RaG1tXU+t7whTE5OCjabTbDZbILL5RI8Ho/g8/kuu87n8wkdHR3Cyy+/LOh0OuHNN98UHA7Hoo1TEATB6/UKx48fF+6//34hJiZGem7l5eXCSy+9JLhcroDc98SJE8LatWsFtVotvS+ZTCbExcUJ5eXlwjPPPCM0NDQIZrNZcLvdgs/nE3w+nzA1NSWcOXNGKCsrm/O7OTk5wkMPPXTF57xQsFqtws6dO4WEhARBoVAIarVaCA0NFbRaraBWqwWtViuEhoYKycnJwhe/+EXh8OHDwtDQ0I3e5sPWzXL9uiL8fr9w7Ngx4f777xdkMpkACICgVqsFg8EgPPvss0JdXZ0wMzNzzYfi9XqFEydOCI888oggk8kEuVwuFBQUCP/xH/8h2O3263mu1w2/3y/4/X7B5/MJbrdbmJ6eFnp7e4UTJ04Iv/zlL4UvfvGLwvbt24WwsDBBoVDMmb/BwcFCTk5OQOehw+EQnnjiCaGwsFB6FsnJycIXvvAF4ezZs0JnZ6fQ1dUl1NfXC88884xQXl4uxMfHC2q1WrjzzjuF1157LWBjuxRut1tobm4WvvCFLwhRUVFCQkKCUFFRIfzgBz8Qzp8/v2jjuBRer1dwuVzC9PS0YDQahQ8++EB49913ha997WvCnXfeKRQWFgoKhUKQy+VCfHy88Oijjwo9PT03c6srrpeAuSZi4a1CoSApKQmtVotGo8FkMnH+/HnefPNNurq6pPKEo0ePkpeXh8PhWBQ5p9mqDtfyjMScQEJCAlqtFkEQ5i3qfaOQy+Xk5ORgMBiIiYlhfHxc6pHp9XoDJpIdGhpKfn4+ZrMZq9WK1+slISGBu+++m40bN1JaWkpiYuIcVRRAEpWPiIggODgYl8sldWLx+XwBFfVWq9X81V/9FQcPHqSjo+OK15hMJmw2G0eOHMFkMlFcXMzevXsXPCzzUcLMzMycd5OcnMzq1au577772LJlC/Hx8R/KCwgKCiI7Oxuv10t6ejpDQ0OS4PdCv/PZBDDxZBEfH49Wq5VIQWNjY/T29mI0Gunq6qKhoYHh4WG8Xq8kZp2WlhYQhReVSsWtt96K1WolPz+fkJAQysvLycnJITMzUzpJi9GygYEBlEolVVVV1NXVSWTGxYBSqSQ5OZkHHngAl8slNWEQlab6+/vZs2fPop8ixQgVXCR5RkdHMzMzg06nY3BwkPb2dp577jmGh4ex2+28//77rFu3DqVSuSAEnUXZCTQajRRDttls6HQ6hoaG6O3txe/34/V6aW9vp6amhujo6EUxjtf7kmcrcYiC3osdZhAFnKOjowkPD1+0XJlOp6OkpASr1crw8DAOh4M1a9awe/duysrKrkoGCgoKIiYm5or1bIHuaqJUKtm5cyd+v/+qZSPd3d309PTQ1tbG4cOHGRsbo6CggPT09D9Z4ygKNMfFxSGXyykqKqK8vJx9+/ZJEl3Xg7i4OLxeLykpKYyPjy+qM6lSqVCpVERHR5OZmSkJfjc0NFBdXY3NZpPKt7xeLyaTSXJ6FxoKhYI1a9ZgsVgkEl9lZeVltdJqtZrw8HA2bdqE3W7n3LlzDA4OziEaLQbCwsLYtGkTfX19aDQajhw5woULF/B4PDgcDrZs2UJ4ePiSrQ+tViu9p4SEBKxWKwaDgfPnz+P1eiXN15qaGolhPV/hkUX/SyMiIigvLyc1NZX9+/fPUT8wm82Sqs5ygcVi4X//93959dVXSU5OlggdfwowGAx8/etf5+tf/zqtra20t7fziU984oaN82wvP9CGXSaTERMTw2c+85mrXiP8sU3Z008/zfPPP8/w8DAffPABFRUVy0akYjEhk8koKirCbreTmJiIVqvlk5/8JKtWrbopFnlQUBBJSUm0tbUFYLQ3No7IyEi2bdtGdHQ0NpuN2tpaidQRyBZaIrZv335d1+3ZsweFQsGxY8fmsFkXCzKZjODgYB588EFycnLQaDQ8/fTTnD59mqGhIT75yU+yYcOGJe2gNBs6nY61a9fy93//9/zkJz+Rols/+tGPaG5uZs2aNURGRs7r/S4ZXS+Qp6+hoSFee+01XC7XvD7H6/Xy6KOP8uqrrzI0NERWVtaiNyBdLjAYDGzZsuW6JpvP52NsbEzqjrHcIBrppSIbLEdoNBo2b97M5z//eR544AHS0tJu+pTgcrk4ceKE1C4qUBCZqdcDUSBAPE0IgoDJZJK6iSw3jIyMXDUtEGjk5uby+c9/nn379rFq1SpGRkb41re+xaFDh+jr61uSMV0JcrmcvLw8DAaDVJojkp0WIlqxJGfkyclJuru7L9s4ExMTSUhImNdnNzY20tPTI9Vk3QjEMIyovGGz2Th58iRWq5W4uDiKiooWtYxjOUGtVl/3qcrpdFJVVYXFYpmjnrJcIDY8bmlpQRAEYmJiyMnJWfTu5ssJYm59IU4GYhPfSzUxFxqdnZ3YbDaio6PJyMi4ZhmYWE4mzGLMiw2YlyMUCsWSjS00NBSDwUB5ebnUW7KlpQWj0UhKSkpAVK48Hg+1tbVYLBbgYl/VqKioq+63Pp8Pt9tNb28vExMT0lzzer1z+nzOB4tuHH0+H4ODgxw+fFj6Q0Qvvri4mKKionl9/u9+9zv6+/tJSUm5oVOLqBPZ2trKL3/5S5qbm+np6WFiYoL8/HzKysr4xCc+sSDtbUQ21KW4kZKC5XgiE2Gx48oUSQAAIABJREFUWPjJT35CZ2fnZZ75Up/UfD4f586d48CBA7z++usSeeOOO+74kwypBgKBJFzNxrFjx2htbSUuLo4vfelL1xTEcLlcmEwmaWxqtZr169cHXC9ZXOsfFnGZzZIEpFZWSwGZTIZarWbXrl2Sc/vWW29JBKaNGzcu6P18Ph8TExP85Cc/kWQov/nNb1JaWirVoor7hviMpqamGBkZ4ZVXXuHs2bNS+dFCYtGN41NPPcXhw4c5evSoFBKJioriO9/5DnfccQd6vX5eny/WxxiNxus6OQqCwMjICK+99hrHjx/n3LlzUrfz0NBQPvvZz1JRUUFJSQnJyckLkqOoq6vDbDZLNYBwMT+i1+vJzs6+puTVbILDYm1CN4Kuri6qq6uprq6+zDAmJCSwevXqJTOQXq+Xn/3sZ7z//vucP38egPvuu48dO3YQGxu75Ib744DBwUGamprm9FIMFGJjY2lsbOQXv/gFxcXFrFu37qqdaqampujp6ZEaCqhUqkVpE3X06FGcTqfUieNqaGxs5Pz587S3ty+LxuIymQyDwcBf//Vfs3XrVk6fPs0777yD3+/nrrvuQqPRLMh68Xg89Pf3s3fv3jmKak899RSbNm1i27ZtUsMCURS/sbGRwcFBhoaGyMjIAC6mBRY6SrWgxtFqtVJfX4/H4yEqKoqoqCiOHDkyx0i98847tLe3Mz09LZEnsrOz2bBhA5GRkfOerAkJCXR1dXH27Fn+93//F4PBQFJSEgUFBXNeZmtrK8PDwwwNDWE0GqWJKVK9ExISWL9+PXfffbek07hQyfumpiZqa2vn5BTkcjmJiYmsWrUKnU6HTCbjlltuQafToVAoGBgYoLOzk7GxsavqmAYafr+f6elpSZjg0jDWxMQEVVVVHDx4EJfLNac0QK/Xs379eioqKhZ93IIgMDg4SF1dHW+99Rbt7e243W5uueUWNm/eTF5e3ophXCCMj48zODgoGUZRnzUQzzcxMZH4+HgsFgvV1dVotVpiY2Mvm5dWq5W+vj6am5vx+Xykp6dTWlq6KKzvkydP0tDQQH19PXfeeecVmwgDVFdXU1dXh8fjWTZOb1BQEBqNRmIr2+12zGYzbW1trFmzZkHCvsIflW5Ewyg6Bv39/dK61Wq1BAUFSdq/w8PD+P1+FAqFdGoU+SUbN25k48aNaLXaec+5BTWOExMTHD9+nPHxcfR6PampqfzqV7+ak3tobGzE4XAQFBREcHAw6enprF+/nqysrAXRFExLS6O1tZWBgQFeeOEF8vLyJMmr2ROyqqqK5uZmGhsbaWpqkqTtxMakubm5VFZWsn379gXrKCBCFG9+//33pe/JZDJ0Op3EFoSLp+CUlBRUKhV1dXW0tbUxPj4uKUSIElmB2tjFU6qoNuPxeBgeHkapVKJWq4mKipKuEwSBzs5Ojh07xqFDhySHSKx3zc/PlybuYsDn8+Hz+ZiZmWFqaorGxkb+8Ic/cOLECWQyGQkJCezatYt169aRkpKyKGP6uMPj8WA2m+np6ZHSJWq1mpiYmICc0JKSkkhJScHr9XL27Fmio6PJzs4mKSlpzpoQHUsxmiQ2+F0MNDc38/bbb3P06FEiIyPZsGGDxAYV9yOPx0NNTQ1NTU34fD7UanVASybsdruU0hLLM67HURCNU29vL/n5+QHNiYotBZuamqTxCX+UNISLUQODwUBTU9PFgv0/1tPv2LGD8vLyBTnZLugbcLlcdHd38/rrr+NwOJDL5ZeFVsRNUy6XU1JSwuc//3nuuuuuBSO67Nq1i9DQUFpaWjhy5IjUbeOb3/zmZdfOjvHHxMQQHx9PcXExDzzwAHl5eej1+oAYns985jPodLo5xlFkeFosFmmi1tTUSD+/9DnGxcVhMBjIzc0NWGhI1IF87rnnGBkZYWJignfeeYeIiAji4+OlelTRiJ47dw6TyTSnRis0NJTk5GR+8IMfkJmZGZBxXglms5n+/n7Onj3LiRMnaG1tpbGxEUEQ2LVrF7t27eLhhx9ecMfnTxWCINDY2Mhbb73Fm2++CVxcU4HM52ZmZkp6uYcOHZJqp3/4wx/OOT2++OKLHDlyRGo9V1JSwl133bUo0YKCggK6u7uprq7mK1/5Cjt37uThhx9m/fr1REVFIZfLaW5upq2tTeqEsmXLloDlGwVB4Gc/+xlGoxGHw8Hf//3fk5WVdV3dS2QyGeHh4RgMhgUz3kqlkpiYGO6//372798v6c7OxpXCzEqlkvDwcGQyGVFRUeTn5/Pzn/+cpKSkOY7HfLCgxlGlUpGcnIxMJrtmvk8s0v3mN7/JmjVrFrw8IjMzky9/+cuo1Wrq6+vp6uq6LFRRUlJCREQEGo2GkpIS9Ho9cXFxJCUlkZycHLBQEFys0dm6dSu//OUvgYt5upaWFqqrq7FYLFKIQDSIs1l24kvPzc2lsLCQ9PT0gBhHMQfym9/8ho6ODlwuFx6PRxL0drlcc6j6fr8fu90uxf3Fk3BeXh6f+MQnSE9Pv+n6UEEQJJHmK/3M6/XS09OD2WzGZDIxMDBAQ0MDvb29jIyMYLFYcDqdaDQabr31Vu644w7Ky8sXvfHtRwkiA1DchK71nMbHx+ns7OTZZ5+luroas9kMQHl5ObfccssNiQjcKGJjY9m3bx//8z//Q29vL++88450gtDr9TQ3N3Py5Ena2tokpam0tLRFa2V16623Eh0djU6n49SpU5w/f55/+Zd/ISMjg7i4OIKDg2lvb6e5uRmPx0NMTAz33XdfQEXRc3Jy6Orqora2lkceeYTS0lIyMzOvqBk9Pj5Oe3u75PCGh4eTkZGxoHuOSqWisLCQ48ePX/fviJGs4uJi9uzZQ0VFBXq9HpVKtWBjW1DjqNVqWb16NSqV6qrXZGRkkJ6ezrp16ygrK0On0y345q7T6diwYQPd3d3ExcXR2dkphXlElJSUEBkZiVarpbS0lISEBHQ6XcDZa3BxMuj1em6//XYAOjo6SE5ORqFQ0NfXJ03Evr4+nE6nZCRjYmKIiIhArVZTUlJCfn5+wAQJxPDJqVOnmJqamuPsiEbS4XAAc4lBogFXq9WsXbuWkpISbrnllnmpa1itVrq7u6VwrkKhkJqgut1urFarlEM2mUz09/fT1dWF1WqVwuRig9fbbruNDRs2kJ6evmIYrwFRBFsul5OZmTlH7UicgzKZjKmpKYxGI0ePHuXUqVMMDg7i8/lISUmhtLSUNWvWBDREGBERwZYtW3jvvfcYGBigp6eHgwcPIpfLMRgMNDQ00N3dzeTkJCqVig0bNqDX6xetx2dGRgYKhYLx8XG6u7sZGhri/Pnz9PX1odPpUCqVDA0NYbfbiYiIIDMzk+Li4oD0J4SL61Psc9rY2EhLS4skGbdq1arLrrdYLAwMDODxeEhKSiIhIWHBy9mCg4PJy8tj06ZNREZGSuQpp9MpkfrEFJK436WlpZGXl0d0dDQVFRVs3LhxwcO8sg9J/t5wZlgQBKm90pVOXt/97nfZtGkThYWFKwzBWfD5fJKkmcViQRAEnnzySXp7eyXjtGfPHkpLSzEYDGzbto34+PhrOiLzQX19PYcOHeKxxx6TimrF0+uluNQ4KpVKUlNT+bd/+zc2btxIfHz8vMZy4sQJnnzySUJDQ6XF2dHRgSAITExMUF9fj9lsxuPxSOMTowDFxcVs27aNgoKCeZcJzcJHddJe93r+6le/ynvvvcf4+Dh33XUXcXFx0sZUUlKCwWAgODiYpqYm3n33XZ555hmcTidKpZLIyEjuvfde/u7v/o6cnJyAMkL9fj9Op5OHH36Y6upqieQmGvCpqSmcTicKhYLo6GheffVVsrKypHz5YmBmZgaTycT/+3//j3PnzkmdL8R1I87ZwsJCHnzwQb74xS8GvKdjd3c3dXV1/PjHP6alpYXR0dFrEoFkMhmf/vSnue2223jooYcCMqbJyUnGx8cxGo08/vjjGI1GSWM2KiqKhIQESkpKAFi3bh333HMP8fHxKBSK+dqRK/7yghtHuHjiuRodOTIyErVajVKpDDiN+qMGr9crCUDDxaS0yF4TBAGtVotKpUKhUBASEhJQhZeZmRmMRiMvv/wyY2Njl4XJx8fHOXr0KHa7fQ7hasuWLWzZsoUHH3wQvV6PRqOZ93vu7Ozk4MGD/OxnP2NiYgKn0ynNL4VCIelCrl27lsLCQuDiYtLpdERHRxMSEiI1Pl4gfOyNY1tbG7W1tfz617+moaEBp9Mp/UxspySTyaR2QXa7nbS0NHbv3k1FRQUVFRXodLpFKWQXBIHnnnuOt956iz/84Q/4fD5pbXi9Xqmn5F133cVDDz0U0DDv1eD1ejGbzZIBeOWVV2hpacFsNhMZGUlRURHr169n9+7di9JH0ev14na7GRkZYXJykoGBAX7/+98DF7kGYplZeHg4iYmJc5i2gXIsRO6C2JDe4/FI63x2mzy4GH3TarULFZW44sMOSLwjEAoKfwoQu5iIWEoNV6VSKeVupqamLiMEORwO8vPzpZ5rInJycsjOzpYUSxZikUdFRVFSUsJnPvOZOXlNuBhuCQ0NlXJJYp2sRqNBrVYH7GT9cYfIHXC5XCQnJ2O323G5XIyMjDA8PMzExAR2u11S1Vm9ejXbt2+npKSEgoKCBRHLuF7IZDKKi4ux2+1MTExQU1MjlRJptVp2795NSUmJxGJcinC6QqEgISGBmJgYEhMTmZ6eZu3atdjtdjQaDQaDgZSUFCIjIxclmibuNXq9XnIgxDUudlKBi46QTqdjzZo1AWfRzu7ktByIcgE5Oa5gBR9zfOxPjrNx4cIFbDYbdrud+vp6zp49K7U1SktLIzs7m5KSEu6//36ioqKWTGmoubmZw4cP88wzz2C1WvH5fERHR/Pv//7vFBcXExcXtyTjWsGyx+KFVVewgo85/qSM4+ySJ1GjVMyZiR3Zl4OQuxiWuzSlo1QqV8hXK7gWVozjClawQPiTMo4rWMHHHFdczyvu1ApWsIIVrGAFl2DFOK5gBStYwQpWcAlWjOMKVrCCFaxgBZdgxTiuYAUrWMEKVnAJFr2f4wpWsJjwer0Se1Euly+abNgKVrCCjzZWTo4r+NjCZDLxxBNPsG7dOtatW8eDDz4oNVNdwQpWsIJrIWAnR7GTgtfr5cKFCxiNRs6dO8fOnTvJyMiYowAvk8kIDg5elBopr9fL5OQkbrd7jurLzMwMDoeDtra2y35ndHSU0dFRJiYmyMzMJDs7m+3btwdULWIF80NDQwM1NTW88cYb9Pb2Av/X43EFK1jB8ofYb/eee+7BZrPR39/PwYMHJeGJ4uLiOQ2SIyIiFvT+AdndBUGQ9BZHR0c5duwYVVVVvPHGG7hcLkpLSyW1dbgoAZaamirprQayYHd6epr29nbGx8fnFAu7XC7Gxsaoqqq67He6urro6elheHiYsrIyduzYQWlpKWFhYSvC6ZdA1IednJycI2Q8MzNDcHAwarU64O2CXC4XNTU1vPvuu5w+fVr6/sDAwGUyeCtYOIyPjzMzMyPpdqrVajQazaK1h1rBzcPv9+N2uxkbG5O0klUq1Zy0BFyUnVOpVMTFxQV0n56YmKCxsZFDhw5RXl5OV1cXjY2N7N+/n9zcXPx+P8XFxczMzEhykgttHAMiAuByuTh37hwHDhzgiSeekLpOX9qTUERSUhL//d//jcFgIDIyEp1OF5AH7/V6qa2t5atf/eplYsoirvU8xPFv3ryZn//85+Tm5i6KsPJHCT09PbS0tPD888/jcrmk997W1kZmZiabNm3iO9/5TsAWltfr5YMPPuDRRx+d00waLupEDg0NodPp5nubj6pHFDARAI/Hw3e/+12MRiM9PT3U1tZSVlbG7bffzve+971A3XYFCwCfz4fNZqO+vp4vfelLdHZ2IggCJSUl9PX1SZ0xAOLj4yktLeW5554LmNMjCAKPPvooVqtV4gns378fr9fLU089RXV1NdnZ2ezbt2+hbrl4wuOnT59m//79vPrqq5JhhP9rzXKp9z4yMsI//uM/Sn0Kv/e9731og9WbgcfjwWq10tLSgtvtvqYhDAoKIjg4+DKF/LVr17Jly5YF7Yb9UYbNZsNkMtHV1cXp06dpa2ujp6eHnp6eOW15pqamsFqtWCwWHnjgARITEwMiLjw1NcW3vvUtWltbpe/dcccdZGRksGrVqmUhaPxRgNPpZHJykqGhIeLj47HZbAwPDzM4OIggCHg8HsbGxhgeHmZqagqHw8GZM2dwOByS0zk2NsbY2NgS/yVLD6vVSnV1NUajUdp3hoaGGBgYwGKxXHWfCwkJ4c477+S2226TBPUDgTfffJOqqipOnDjBwMCA1J6up6cHpVLJ6tWr2bZtGzKZjNDQUAwGQ8AE/ScnJzEajRw4cACTySR9f3p6mrS0NIKCgrjnnnuIjo4OyP1nIyC7+9jYGAMDA1Ku58MwMzPD+fPngYsh1vHx8YC0lRFDB2I7FpVKhVqtRq1WExMTM6fRcXBwMBqNhuTk5DktlwoLC8nPzyc0NHRRQ6per3eOxuXY2JjUeQAuelter5fh4WFCQkKIiooiNzc3oGMSBIGmpiZaWlpoaGigurqa/v5+xsbG5oTNZ8NutzM9PR2Q3J/YNaK2tha3241Wq6WgoICdO3eSnZ2NXq9fOel/CHw+H0NDQ3R2djI0NERvb69kHE0mE8PDw5JxHB0dxWw2MzU1hcvlYnp6GpfLJYW5dDrdgoe6Poqw2+2cOHGCCxcu4HQ6EQQBk8nEwMAAVqtVaqcWEhJCeHg4ISEhaDQagoOD5ziYgYLRaOT06dPSHiyXywkODiYtLY3U1FTS0tLYunUrcHHPDGQrMrfbzdDQEIODgwwPD+Pz+VAqleTl5bF27VpiYmJIT09fFHH7ZXf0cTqddHV1kZCQsOBCxpeGdHU6HQaDAb1ez/bt28nOzpZ+rlQqiYiIID8/f8n7TgqCwOTkJB6PRzp1Hz58mKGhIRwOBzKZDI/Hg91u59VXX0Wv17Nt2zb+7d/+LaBjcrvd/PrXv+bkyZM0NjZe9VqZTIZMJiMuLo7MzMyAka9GR0dpbm6WnlFKSgqPP/44JSUlcxyfFVwdTqeTt99+m5deeommpqYPPfmJ7zEoKAiDwcD4+DhWqxWATZs2UVpaGvAxXwmzHUlxjNc758TfXSjn3GKx8Morr9DT0yM5jWJ7Jo1GQ1hYGAkJCej1egoLC0lLSyMjI4PU1FQiIiIC7mCYzWaGhoak/6tUKqKjo/mrv/ortm7dSnZ2dkDvPxsej0fKXft8PmQyGWFhYezdu5c9e/awZs2aRRvLsjOOdXV1/MVf/AXHjh0jLS1tQUOXarWapKQkdu/eTVVVFTk5Odx3333ce++9UuPM2QtI7DSwlLBYLBiNRr7xjW9gsVikxeVyuaRGyCIEQWB6ehqr1Rrw9jxNTU186UtforGxEafTiUqlkprLign8hIQEDAYDGzZsoKioiLy8PDIzM4mKigrIcx0aGuLcuXPSMxFDfatXr14xjtcBMVT6/PPP09bWJhk5EQqFgqysLLxeL3K5HL1ez8aNGwkLCyMoKIg77riDyclJbDYbSqWSzMzMRSXjzMzMSFGJN954g5MnT9La2kp5eTmrVq1i1apVKJVKIiMjiYqKIiYmhuDgYIkEaDKZ6O7uprm5mV/96ld897vfZdeuXQs6xoiICPR6PZ/61KdISUkhISGBNWvWSM18RVLi7HEFuqPIpk2bsNlsvPDCC3i9Xnbs2ME3v/lN1q5du+hpiMnJSRobG3G73VKv1r/5m79ZdMMIS2wc4+PjUalUlx3RA8VYlcvlhIeHs3btWqqrq/F6vVLX60vr30RW5VKH4fr6+jh48CBGo5GpqSmJSQb/Rx7KzMxEo9EQEhJCamoqWq2WwsLCgI7L7XbT0dGBw+FAq9VKoZe+vj5GRkYIDQ1lw4YNpKenS41c4+PjA9ZFHC6GBGeX6Njtdg4ePIhWq6WkpISysrKA3fvjAHEjnl3yotVqycvLIykpieTkZLKzs5mZmUEulxMfH4/BYECtViOXyzEYDLjdbtxuN0FBQYSHhy/a+jGbzbS1tdHQ0MD09DSnT5+mpaUFk8mEx+OhsbGRmJgYFAoFoaGhREREkJycjFarJSQkhNDQUM6dO8fg4CCDg4M0NTVht9sXfJyxsbEUFxdTWVlJdHQ0YWFhJCUlLfh9bgRr1qzBarXy+uuvMzU1hU6nIzc3d9FTR3Axt9jR0SE5YKGhoWzevJmkpKRF34uXzDgGBQWRlpZGbGwsoaGhc04SMpmMkJCQgLwYjUZDTk4OSqUSu91OV1cX1dXVl51koqKiSE9PJz09/bITZaAh9qWz2+00Njby9ttvMzk5CVwM96pUKuRyudQ1u7S0lOjoaKKioigrKyMhISGgCWu/34/H45EcCpHB9rWvfY2amhra29uJjY3ljjvuICEhYdGeXXBwMFqtFrlcjt/vZ3JykiNHjjA+Ps7IyAgZGRlERESgUChW+vtdAaJRDA4ORi6Xo9FoSEpKYufOnaxfv55169aRkpIiRQa0Wu1ln7EUjY59Ph9tbW289957vPnmm7jdbkZHR3E4HPh8PmpqauZcr1AoUKvVpKamEh4eTkREBDExMbz77rvYbDbJAZ3tiC4EZDIZiYmJlJWVUVJSsuSOt4i8vDymp6cJCQnB6XSiVqsvIyIuFtxuN4ODg3i9Xin0rNfrUalUeDyeRX1mS2Yc5XI5mzZtYteuXaxfv/6y8EugmKBi6Mjv90tkkmefffay69RqNdHR0fz+978nLS2NsLCwgIznSpiamqK5uZkvf/nLtLW1SR5sSkoKGRkZ3HPPPaxatYrU1FRyc3OljX52TjWQE9tsNtPf34/L5UKn07F582a+8pWvkJaWhsFguGrJTqCxYcMG0tLSePzxx+fUZtXX13PhwgWeeuopXnrpJdauXUtycvKiju2jgMbGRo4cOcKZM2fQarWUlpby2GOPUVhYKJ0OgYAxFW8GLpeLoaEhHnvsMdra2nA6nfzt3/4tNTU1tLW1MT4+PsfgwUVym8PhoKWlRfqeeGIWodFoFjz0Hx8fT2FhIbt27VrWTPfJyUn6+vpIS0tbdAMZFRVFZWUlHR0dWK1W+vr62LlzJ3/913/NrbfeSmlpqZTCCTQC8oZiY2Ml+u/AwAAjIyPSyUeEz+fjnXfekU4gu3fvJiQkJKA5PrfbTW9vLy+88AJ2u106oV2JOSl2O3/ttdeoqKhg3bp1i5K3MpvNNDU18dOf/pSuri7cbjcRERHcf//9rFu3joyMDNLS0tBqtWi12iXRCp1t+MQwpjhhl/JEJlLN//mf/5mXX36ZCxcuSD8TT5KPP/44999/P7t27SIzM3PJxrocMTU1hcViwefzsWvXLiorK8nJyZljGK8Fh8MhMS8XC93d3Tz66KM0NDSQl5fH7bffzu23305lZSV2ux2bzYbRaGR6ehpBEBgdHSUkJISQkBAUCgUej4fJyUl6enqIjo5Gp9MRGRlJXFzcgqQmOjo6qK2tZWhoiNLSUnJychY1mnK9iIiIoLKykrfffhuTycSZM2dITk5e9NNtWFgYBQUFaDQaJicnpRrMV199lZqaGoqKisjJySEvLy/gZK+AGMf4+HgpeSp67T6fj+npaekav9+P0WiU8hKbN2+WktGBgtfrxWq10tDQMOf7MpmM8PBw1Go1MpkMQRBwuVw4HA6qqqqIiooiLi6OnJycgI1NhNFo5NSpUxw9ehSHw0FQUBBqtZrCwkJWr15NamoqOp0u4I7EtaBUKtFqtURHR2O32xkfH6enp4f09PQlD1eqVCruuOMOent7cTqdkmMmMhCrqqpISEggLCyMuLg4tFrtkpOulgs8Hg8ulwuA3NxcCgoK0Gq1jI6OSs6izWbD5/PNqVUWySQ2mw2NRoNGo0Gr1UplUoEidUxOTtLb28vhw4dJTExkw4YN7N69m/z8fCm0Pj09Pcc4Dg8Po9FoCA0NlYyj1WrFaDQSFxdHdHQ0MTExxMXFkZCQMO8xtre309jYiN1uR6/XB6y+d75Qq9VkZ2dz6NAhyaFYCjUpjUZDdnY2hYWFdHV1MT4+jsPhoKOjg/7+fgYHB+nq6pKcnIiICMnZWejDS0CMY25uLrm5uXziE5/g+PHj/Pa3v+XUqVM0Nzdfdu25c+cwm8089NBDhIWFLarXKZPJJPKP6NXJ5XIpKXzs2DFJZcXr9ZKdnR1wj+/FF1/kjTfekGoxlUolCoWCgYEBzGazlKDOy8sLiFDC9SAqKorMzEx27tzJH/7wB86ePcsTTzxBWVnZkiTxZyMoKIiioiK+8Y1vUFFRwbPPPsu5c+dwOBzSNa+88gqnT58mJSWFdevWLYRizscOYWFhqNVqzGYz+/fvx+FwMDMzw8GDB7Hb7XPClBqNhujoaCmCEBYWRlFREbm5uRgMBgoKChZ8fH6/n/r6eurq6ggODuanP/0peXl5c9S1REJHcXHxgt//enHs2DEOHDiATCYjNzeXpKQkSVpvOUGhUBAZGUlQUJDExVgK4xgeHk5paSlPPfUUVVVVHDx4kJqaGkwmEw6Hg8bGRhobG3nvvfd48cUX2blzJ/n5+WRnZ7N58+YFHUtAA98KhYKNGzcSFBREVlYWv/71r+nq6rpMtm1qaorXX3+dP/uzPyMjIyNgnpVSqSQnJ4fvf//7AMTFxZGamoperyc0NFTKpQiCwNmzZwkNDeW9995jaGjoioY9EIiJiSE+Pp6RkRHgYthyZGSEX/7yl1K94DPPPENJSQmbN2/mvvvuIyYmZtENUkpKCv/8z//MmTNn6O7u5syZM/zsZz/j9ttvDzhT9nqwatUqkpKS2LRpE88//zzHjx/nyJEj0s9FicPMzMwV43gFPPnkk/ziF79AoVBI4S1gzr9FiMQJ8d9yuZxDhw6RkJDA2rXobYCNAAAgAElEQVRreeihhygvL1+wXKXP52NwcJBnnnmG48ePS6kZj8ez7KIAfX19dHd3A/Af//Ef/OY3vyEjI4O9e/eyceNG0tPTl3iEl8NkMnHy5MklFelPTU3l7rvvZseOHYyNjeF0OhkbG+PYsWPU1tYyODhIa2srg4ODaDQadDodxcXF3HXXXeTn5y9IyiTgWWGtVktWVhZwUcA7JiYGk8mE2WzGbrfj9/txOp1UVVWh1+uZmZmhsLAwIAnroKAgYmJiqKioAC6KAMTHxxMbG3vZtTk5OZSXl3PixAlJEd7hcAQkUT8bUVFRpKWlXXFiOhwOHA4HXV1dwMUwmE6nY9++fYvuiSqVSlJSUoiLi2N4eBiHw8HRo0fJzMwkPT19UQlMV4JKpUKlUhEREUFFRQVBQUFMTEzQ0NCA3+/H5/NJbMYVXI7Z0l2zIYZKg4ODUSqVJCYmIpfLJWUcMT/Z19dHX18fXq+X0NBQQkNDSU9Pv+JauxnMzMxICj0qlYp3332XoaEhcnJyKC0tXTaEl/Xr1zM1NcXIyAgymQyn00l9fT0qlYrp6Wnsdjtr165d6mESEhJCXl4eWq0Wi8WCzWZjdHRUYvYuNsTctU6nIzY2VmLviyV2nZ2dtLS0MDQ0JMlSulwuBEFgbGxsQeQ9F2UGJSUlERYWht/vp62tjaamJk6cOEFLS4tkHI8ePUpISAiTk5NkZ2ej1WoX/DQkl8uJjIxky5YtH3ptQkICO3fu5Kc//Sk2m42enh7MZjPJyck3dbIVczaCIFyzNCQ5OZnCwsIrej59fX309/fjdDrp7+9ncnKS0dFRdu/ejVKpXNQQq3haWLVqFaOjo3R2dnL06FE2btxIYWHhkhvH2di2bRsRERE4nU5aW1ulRTQzM7PSpeMaEN+xqFQlOpeRkZGEh4cTHh5OeXm5JPk4OTkpFdbv37+f7u5uuru7aWtrIzY2lh07dhAdHb0g8zQoKAitVotGo8HlcvHss8+SkZHBxo0bycnJWdQay2vh05/+NOXl5Zw5cwalUsn58+d56623eOmllxgaGsJsNi8L4xgeHs727duJjY3FZDIxMzNDd3e3lDteSoj312q1JCYmotfr6enpobW1lWPHjtHa2srAwABGo5G2tjZMJhP33nsvERER87MhIlHhKl8LCq/XK7jdbuH9998X7r77bkGtVgtyuVz6UqlUwu233y6MjIwIPp9voW9/w3A6nUJ5ebkQGxsrREZGCt/5zneE9vb2m/qs+vp64be//a3w9NNPC319fVf9+2ZmZgSXyyU4nc7LvqampgSTySS89tprwr333ivk5OQIKpVK+PnPfy5cuHBB8Hq98/lzbwo2m0145ZVXhMrKSiE4OFjYunWr8P3vf3/Rx/FhqK2tFb797W8LarVa4GJ3CkGlUglHjx69mY/7sHWzXL+uiWPHjgnf/va3BaVSKSgUCiElJUX48z//c+G5554T9u/fL5w8eVJoa2sTRkZGBIfDIUxNTQkul0twu93SnHW5XILL5RIcDodQXV0tPPHEE0JqaqoQFxcnPPzww8IHH3wg+P3+m3nmc+D3+4WpqSnBaDQKP/7xj4XMzEwhNDRU0Gq1wu7du4WDBw/O+x4LAb/fL+17brdbqKurE/793/9dUKvVQkJCgnDHHXcINpttSdbulfCf//mfwt133y2oVCrhhz/8odDQ0LDUQ7oMPp9P8Hg8gtvtFqampoRf//rXwv333y8kJiYKWq1WWL16tfDII48INpvtej/yiutl0WIP09PTNDY20tfXR11dHYODg5d57R6PZ1mFuRQKBUVFRdhsNgYGBi5rkHwjMBqNHD58mJGREXJzcwkJCSEmJuay6z7M2w0ODmbDhg1SjWF7ezsHDx4kJiaGrKysRc+5iCr9mzZt4tSpU3R3d1NbW4vVapVkxZYrPqwzy58asrKykMvleL1efD4fMTExlJWVkZqaSkhIyByh/g97ryqViszMTFwuF7fddhsvv/wyQ0NDdHR0UFpaOu+okEwmkxoD7Ny5E7lcTnNzM83NzXR2dtLc3MyqVavIyMiY133mC/HELT6vtLQ0tm/fTmZmJqOjo/T29nL+/HmKi4sJDw9f0rECUvndW2+9xdtvv01UVJQUEl8umC2pp1Qq2bx5MzExMej1et544w0sFgsHDhxg165dZGVlXXGfvR4E3Dg6HA6mp6cZGRnh1KlT1NXVSY2Dl3tISxAEoqKi0Gg0APNSyDeZTDQ2NjI4OEhdXR0ajYbw8PAbZucGBwej1+vJyMiQSEKtra0S3X6xIZfLiYuLo7i4GKVSKYVYTSYTKpVq2dDWRanA2e8vJCRkyUtPlhMSExOJiYlBo9Hg9/sJCwubV/lSZGQkmZmZbN++nddeew2bzcbIyMiCOiQajYb8/HwiIyNZtWoVWq2W+vp6ent7GRgYWHLjeCl0Oh35+flkZWVhtVoZHR2lvr6e3NzcZWEcc3JyyMzMJDQ0lJqaGrKzs0lISCAtLW3ZrpWMjAySkpLQarW0tLRQW1tLXV0d9fX1hIWFLU/j6PF4OHTokFTGYTQa6e/vv2o7o+UEn8/H1NQUb775Jj09PfOeGGLupq+vjx/84Ads376df/mXfyErK+uGEsfCH9sFPfvssxw/fhy5XE5ubi6JiYlLlhvQ6/VERUURHx/PwMAAo6OjHDx4kH379i0b4zg2NkZNTY0UmVCr1ZSWli6LDWk5ITg4eEFLH+Li4tizZw//8A//sGCfeSUkJiYCF521p59+GovFwujoaEDvebMICgqisrKS4eFhWlpaOHbsGLfffvuC1FUuBFJTU7n99tt5/fXXefPNN+nq6qKiogKNRrNsDWRISAhbt27F5XJx4MABfvzjH/Ob3/wGjUZz06VE8zKOdrudoaEhnnvuuSueWnw+Hy0tLfT09Eh03IXWKwwEZmZmaGho4OWXX6avr4/p6Wmio6PZtGnTTdP+9+zZQ2ZmJq+++irvvvsuTU1N/Ou//itlZWWUlpaybt266/qciYkJfve731FdXc3o6Cjx8fE8/PDDrFmzZsnrC9esWYPb7Zb6+S0X/OVf/qXUa1KUlVOr1RQVFa106wgwrFYrNTU1i+IQi13jAclZW46QyWRotVqCg4Pxer2MjIwsqzVTVFTEt771LUwmE52dnRiNRh577DE++9nPkp6evqzkAy9FaWmpFJ2w2WyXlQ3eCG7YOIqi0+fPn2dsbIyhoSEOHz58xVyh8EdardVqnaOOczXk5OSQk5Mzr35/Yldyq9VKbGwsGo3muk9Ufr8fr9fLhQsXOHnyJMeOHZMEeRMSEsjKyrqi2PL1IDExUZJEcjqddHZ2cvr0aUniymq1Eh8fT3JyMmFhYVf00CwWiySULk6AmJgYDAbDktTqCX9kfDocDoaHh+e00FqskKXH48FmszE+Pj5nDg4NDUmatEeOHKGnp2fO7wUHB5OZmblsTrYfR/j9fsbGxjh16tSCbP5msxmFQoFKpbqiU+NyubBYLAiCIDUOXq4Qxe9FoYLlUnoCF6XksrOzSU1NZWBggOHhYaqqqti5cydxcXHL2jiKDbYFQWBiYgKLxcL4+PhNdQO64TciCnc/9thjjI6OMjU1NUfA92ahUCi47777qKysnFcZx+DgIB0dHZw7d47KykoMBoPUOPlqEP6osSputM8//zxVVVXU1dUBFwvK161bR35+/k1P4uDgYGJiYrjnnnvIzc3lnXfe4R//8R8xGo1UVVWRlJTEbbfdxt69e8nLy7ts0xYEgaamJj744ANqa2uZnp4mLCyM1NRUBEFY1HyjeD+3243VaqWtrU1qeDwxMUFkZKRE6Q/0GKxWK/X19VRXV8/xEt94441rNmAOCQlhzZo1KyfHAMLlctHd3c1vf/tbpqen59WbUJglzBEfHy+pWc3G6OiopKcbGhq6rI2jCJVKRX5+/rJy0kQhh9jYWEJCQnC73Vy4cIHe3l7S0tIC2nZuPhBZpuJeODw8TEdHB0ajkY0bN96wTbmhnd7tdnPs2DEee+wxamtrL2u2e7OIjY2V8nA3K3Yr/LHR7wsvvMCJEyeoqanhpz/9Kfn5+ZJywpUWpt/vp6uriwsXLtDe3i5Jjc3MzCCTyVi1ahUPPPAA991334Jt9llZWTidTj73uc9x8OBBxsfHaWpqorOzk//5n/+R2gTN/tv6+/ulCep0Olm/fj27d+/mK1/5yqKxQv1+PwMDAzQ0NNDY2Mi7776LyWRicnKSyclJpqenCQ8PJz09nU2bNgVsc3K73Zw/f55XXnlFSr57vd45c1HUCL0SKioquPXWW9m0adOyqIX7uEH4ozbxk08+yeHDh+ns7CQzM5MdO3awd+/em5qrPp+PJ598Ep/Ph16v54EHHiA7O5vY2Fhpng0ODlJVVUV6ejqpqakLJjgQSKhUKkncfblgYGCA8+fPc+DAAQYGBtBoNGzfvl3qz7ocMT09zfHjxzlz5gw1NTXIZDKKi4vZtGkT69evv6nD1g0ZRzGOK7aGmc9pJSgoiNtuu43Y2Fj0ej1lZWXEx8ff9CTx+XxYLBYaGxtpbW2VNuzW1lZJ7eFKD0gQBCwWCyaTibGxMcxmM3DRe1IqlWzfvp2ioqIFbUgq9ijbu3cv6enpGI1GOjo6qK+vx2KxMDU1NWess+PnkZGRVFRUUFFRQXFx8aJ0Wp+YmGBgYICuri6OHz8uhVra2tqYnJzE6/Xi8XiQyWQUFhZSWVlJREREwAy2QqEgKSkJj8eDxWJhYmLiun5PJpNRXl7Obbfdxvbt25eko8lHCTMzM5LyiKiAk5GRgUqluuK7dbvdDA8PMzg4yLlz5zh8+DBGoxGv10tZWRmrV6++aeYgXDR+drsds9mM1+slKSkJnU4npToaGxsZHh5m27ZtpKWlLSuDcykEQZBCqjk5OUt+cvR6vVL/2Lq6Ok6cOMHQ0BChoaHo9Xr27dtHYmJiQJ3wmZkZpqensVgswMXojtiM2u/3I5PJUKlU0p7j8/kwmUz09/fT19fHqVOn6OzsZHh4mODgYLZs2UJWVtZNO8A3ZBz9fj8ul+umWGCiooVYIxUcHMy9995LXl4eKSkpxMbGzivXKMoLjY6OYrfbCQoKwufzMTIywsjICPX19df9WUqlUqpD3LVrF/n5+Teda7waYmNj2bVrF+vWraOhoYHq6momJyexWq24XC6MRiOAdBr6/+2deVDb95n/XwKEEAgQIC4BAmHuG2NsYwefsR3fSdM0zq473SbbtEmz3abbSTuddnen2za72067nWmTdtNJ0yRNGudwjnVsJ9iuqRMDNoe5L3ODuCWEAKHz94d/30/BV2JbYLfVa8Z/WBLSB/T9fp7n8xzvRyaTodPpSElJ4YEHHqC0tHRJPWNplJe0lurqas6cOcPhw4eFsox0sUotG6Ghoaxfv55t27Yt6c0uDcqOiooiPDyc4OBgbDYbdrv9qg7bwh69nTt3sm3btk9dAPW3jDRXdGJiArPZLCZbqFSqRRuOFIabmZmhvr6e2tpa3nzzTfr7+7Hb7ahUKtavXy/6e2+W+fl54cC2t7eLdUji/L6+vgQGBrJ582Z0Ot0dlcdbiNvtZm5uDj8/P9RqNampqctmHKV0yOURP2nYwpEjR6ioqODMmTOo1Wr0ej3FxcXs27fP43vg5czPz2M0Guno6MBms6FWq9FoNAQEBOBwOPDx8SE0NJShoSGsVit2u52GhgZqampobGykubkZl8slnOfS0lKSk5Nvej3LdvVER0fz2GOPsW/fPjGlXq1WI5fLPXIRy+VytFotBw4cQKfTcfLkScbGxm5KVCAvL4+7776bxx57DK1Wu6TeUmRkJFu2bGHTpk08+uijzM3NMTg4yNGjR8Vr3P9/ePCmTZvIy8sjLCxsyStTDQYDHR0dnDp1ihdffJHR0VEhuwaXKgOVSiU7duwgOjqa8PBwvvGNbxAcHLxsm9J3vvMdPve5z/HSSy9x7tw52tvbhcjzQg4ePEhBQQFZWVliNJqXT6atrY0nnniCnp4eUVDj4+NzxbUXGBhIWFgYKpWK0dFRMUwcLskhbt26lf3799/SqVEmk1FSUkJVVZX4jhdOWklPT2fHjh089NBDrFq16o4Vn3C73czPz3Ps2DHsdjtpaWnLNnjbbrdjNps5ceLEFVWc/f39vPjiiwwMDOBwOAgKCuK///u/RSh1OfK30r5hMpkoLy8X4/o++OADcf0FBgZiNBqx2+04HA4mJyfFteZyudiwYQPr16/nwIEDorjzptdzK79MeHg4Op2Ob33rW8hkMqampmhubqa1tZWMjAxKSkrEa5VKJSkpKcTFxYlqJ6liyxP4+PgQHBzMrl27KCoqYvfu3bS2ttLf379IRHlmZoaOjg7Gx8fx9fVFpVJRVFSEVqslOjqa2NhYMjIySEhIIDIyclluMklFIzQ0FJVKRXBw8FWrTzUaDSEhIUtqGB0OBwaDgV/+8pdUV1fT19fHyMgINpsNt9uNXC6npKSE7OxsioqKyM7OFmXpISEhy+qt+/j4EB8fz8GDB9m9ezcWi4WZmZkrXpeUlERoaCjBwcHeHOMNoNVq+cd//EfKy8vp6+vDYDAwOTl5RX53ZmaG+fl55HK5aNlQq9WUlJSwatUq9uzZ45HNNTY2loiICIaGhsRjarWaoqIidu3aRW5uLunp6XesYYRLRujcuXPU1NQQFxe3rMUtkrGpqKigtbVVpJAA5ubmRMV5bm4u+/fvF1q4kgjKUqNQKIiOjqa0tJSsrCyRromOjqa3t1eE+MfGxnC73YSFhTExMUFSUhKpqans2rWLzMxMtFotCQkJyys87uvrS3R0NBs3bgQgIiKC5ORk9u7di4+PDyaTicTERBISEsjJyWHDhg3iZy+XUVoK5HI5SUlJaLVaVqxYgV6vp6+vb9HNND09TUJCAqOjo8KgShJZ0dHRxMfHi4b65e4b9PPzE6XqoaGhy/rZElIF6Llz56iqqmJmZoaYmBgR+w8KChL5zlWrVhEVFXVbw1eBgYHLMoT6b5GwsDA2bNiAQqGgt7eX/v5+ent7sdlsIh9pNBqx2WxYrVbkcjnh4eGo1WpSUlLYsmULBQUFFBYW3rJTIpPJyM3NxeFwiMiTtMa1a9eyYcMGkYO83UitRVNTU2g0GpFOMpvNNDc3U15ezuzsLHFxcWRkZCzbuqQ6ioCAAKanp2lubhYnMn9/f6KiosSYt+3bt5OQkLCsjoaPj48Ylh0XFydUreCSMMH4+DgWi0XsN2FhYcTFxaHX68nKymLPnj2ibsUTe7fsE6pNvcKTf2PMz89TX1/PE088QU1NDQEBAXz+858nIyOD5ORkkpKS0Ol0fxFl8kvI7VNbuDVu6X52Op1cuHBBeO9Hjx7lxIkTjIyMMDMzQ0FBAUVFRaxcuZL7779fpE3+1igvL+fYsWP86U9/Yv/+/eTn5xMfH09lZSWnTp3i/fffR6/X89RTT7Fv375lD/P39PTw0ksv8dxzzwkZT61WywMPPMBXvvIV4uPjl+20eIdw1fvZaxy9LELKiUg5Rh8fH6EBK5fLRY74TpWRWib+Jo0j/Fms3eFwMDMzw+zsLE6nE5fLtUiYXKVS3dHhzaVkYGCAlpYWXnnlFerq6piYmMDPz4+5uTmUSiXR0dF84xvfoLi4mMTExGWPUDkcDqamppiamhKKUX5+fiKdc72Ren+leI2jFy8e4i915/Dez8vA9PQ0ExMTVFZW0traysTEhDA2QUFBxMTECC3VO2nu6d8wXuPoxYuH8BpHL17+erjq/fw3HRvz4sWLFy9erobXOHrx4sWLFy+X4TWOXrx48eLFy2V4jaMXL168ePFyGbele3twcJCamhrOnj1La2src3NzfPOb31w2IW0vXrx48eLleiybcXS73djtdlpaWsQw4bq6Onp6erBarZw4cQK9Xu81jl68ePHi5bazbMZREol9+eWXOXPmDOfPn0cmkyGTyZDL5bz55pvs3bv3llTUL8flcuFyuXA6nWLQqjRBQBLzXsjVHvPixctfJ1drY/Pe/14klsU4WiwW6uvrefTRR4Xqe0hICF/+8pdJSEggNDQUHx8fjxpGt9tNeXk5r7zyCu+//z6rVq1i/fr15OTkUFJSgslkws/PT8x8m5ubw+l0olQqiYiIuGPH3Xjx4uXmGR0dxeVy4XA4MJlMi55TKpWEhYXdsZPuvSwvS24BrFYrf/zjHzl58iR9fX3I5XIyMzPZuHEje/bsQa1WiykdntTrdLvdNDY20t3dzcjICLW1tWI+3fnz5zEYDPj7+4vPnJqawm63o1arWb16NSkpKeTk5HhsPZ+WmZkZpqenGRoaorOzE4PBgMFgICgoiODgYFQqFWFhYWICekREBCEhISiVyts6isnpdFJeXk5jYyNGo5GSkhKKi4uXXQja5XIxMjLCqVOnaG9vF2O2YmNjyc7OJjMzk7CwsCWfTeflSubn55mdnWV2dhb489izkJAQj8sRTkxMMDU1hdFopKmpCYvFgsvlYnh4WEx7MBqNi06PSqWSxMREMjIyxDAFL7cPi8XCxMQE58+fFxNFwsPDycnJWaT9Ojg4yOjoqJjIMzMzw/DwMJ2dneTn51NSUnJTY8GW1Di63W5MJhOnT5/m2LFj2Gw20tPTueuuuzh48CCZmZlLpr/odrvp6upifHwcp9NJf38/U1NTNDY2EhAQwNDQEP7+/mL6hclkwm63ExYWhsFgYPPmzaxYsWLZhpA6nU4mJiYYGRlheHiYxsZGzpw5Q0tLCy0tLWg0GjQaDRERESQkJKDX64mJiUGn06HT6YiPjycqKmpJ1jY/Py82lMuZnp7G6XRit9s5evQox48fZ2hoCJfLRXp6+rIaR7fbjc1mo7m5mddee43Tp09jNptxu91kZGSwfft27HY7Op1ODIoOCQlBLpeLaSRSaH3hYG4vN4d03UjTFUwmE5OTk0xOTgKXpuhoNBqys7NFBOdWcblcTE9P09HRQU9PD4ODg3zwwQdixuTw8DAul0sYx4UolUrS09MpKSlh165dHjGOTqeT+fl5JicncTqdyGQyMXlHGtIsfY7D4cBqtV7xHoGBgfj7+3v0WnQ6nWKyijRxx1PfgSew2+0YDAYaGhp4/fXX8ff3R6VSodPpxAlfor6+nvb2dnFdGY1GWltbOXPmDA899BDJyclotdobDpkvqXG02+2cOnWKyspK+vr6SEtL45lnniEnJ2dZjM7w8PCigahmsxmz2bxofZfP/xsdHeXll1+mt7eXyMhItm7duuQnMpvNxujoKF/96ldpa2tjdHR0UchHmpU5OTl5RZ7Ez8+PVatW8fjjj3Pw4MElWV9tbS0dHR10dXVd8dyvfvUrMRdOWtutDLW9Febm5ujv7+eJJ57AYDAwMzMjboj29na6urp477330Gg0QtPyqaeeIjk5GZPJxNNPP83U1BSBgYE8+OCDbNy4kYSEhNvyu/w1cO7cObq7u+nt7aWsrIzh4WGMRqM4salUKgoKCnj++efR6/W3/HlOp5Pp6WmeffZZDh8+TF1d3RWzJ6/H3NwcFotl0R5xq4yMjHD27Fm+8Y1vMDIyglKpJC4ujtWrV7Nq1SpWrFiBWq3GbrfT09NDeXn5Fe9x3333kZOT49FrcWRkhIaGBh577DEOHDjAli1buPvuuz32/rdKZ2cnL730Es8+++yiPdzX15df/OIXIu0lk8kwm83Mzs4KEXWXyyW+c6mu5WZYcuNYVlbG4OAgarWaz372s2i1WhFGXW4CAgLw9/fH7XZjsViuedNIM8WuNvV8KXA6nczMzNDa2sro6Cizs7O43W4iIyPJzs6mpKSEqKgozGbzFRO8ZTIZd999N2lpaR5Zi8Vi4e233+bEiRMYDAbg0ql6dnb2qoOELzfYxcXFFBUVkZeXt+yhS8lLlyaKwKXQndPpxO1243K5GBsbw2g0ilFK3/ve9wgMDMThcHDx4kVRvDUwMEBsbKzXOF4D6YR27tw5YfTgktc+MTFBe3u7uG7m5uYYHx8nKCiI8PBwpqenCQ8PR6/Xs3//fo+lUwYHB6murub3v/89AwMDV410wKUTYmhoKCkpKWLAeHh4OFqtlqSkJNLS0jxSc+ByuTh06BDHjh1jdHQUm82Gy+Wit7eXqakpqqqqUCqV4rPm5ubE/STNv9VoNNx3330en+86NDREdXU1Y2NjvPXWW/T09KDRaIRhcbvdGI1GhoaGGB8fFxEii8XCyMgIGRkZDA8Pi1m5ycnJ5Ofn84UvfOGW1iV1NRw5coTz588zMzODy+USz7tcLiHkLv2dpKJL6XWf1hn6JJbUOLpcLgYGBrDZbKjVatatW7ck+YVPQ0BAAHl5eSLZbjQacTqdV32tRqMhLy+PyMjIZTGOMpkMhUJBVlYWUVFRjI+P09raSlBQEKmpqdxzzz1oNBqmp6evahyLi4s9EhKRpoF/8MEHfPjhhwwPDy963sfHh8TERJE3mp6eJiQkhNjYWKKiolCr1axZs4a8vDxSUlKWPUwjbcrSGKWrcXnYanx8HOCKkJWUs/JyJU6nk6mpKc6dO8epU6cYGhoSIS2TycT4+DhtbW3IZDICAgLQaDQkJiai0+nQarVcvHiR2NhY9Ho9q1ev9kgUyWw209XVRWVlJR0dHdhsNvz9/YmOjiYuLm7RZwQFBREaGkpGRsYi4xgXF0dUVBRRUVG3fN87HA76+vqorq7mwoULuN1u0tLSUCgUuN1uhoeHGRkZEcVBc3Nz+Pr6ilyaXC4nMDCQhIQEwsLCPHovOZ1OhoeHaW5uxmq10t3djdvtpqysTJy03W43ExMTGAyGRcZxenqa0dFRenp6GBkZYXBwELhkHMfHx0lPT6egoOCm1+tyubBardTU1NDd3S1Ogwu/D5vNtsgAXv5dSY6FWq1GrVajVCpv6vtc8pyjNCE8NlA7OFcAACAASURBVDb2th3b/fz8iI6O5qtf/SolJSUAIjF/NbRaLeHh4csWHgwICECn0/Hss8/S19fHxx9/zJNPPklQUBDJycls2LBhWdYxODhIZWUlL7300qLHF47bOXjwIO3t7XR0dFBbW0t6ejqlpaXce++9rFu37rbm6Orr63nxxRcXeZpePIsUdWltbeU73/kObW1tzM7OLvLkpbYpHx8fYmJiuOeee9ixYwfZ2dno9XphHD05rqmtrY3Tp0/zzjvviBNjSEgIe/bs4dFHHyUuLk445b6+vvj5+aFSqTz2+QuRjMihQ4eoq6vDaDQSFhbGI488QmxsLG63m1dffVXkY6enp+ns7CQoKIjMzExcLhfh4eEkJCTw8MMPk5SU5NHUztzcHB0dHZw5cwan04nT6aSzs5Pvfve72O12YRwlrmZYKioqFv2/tbWVwcFBGhsbOXz4MImJiTe1Nrvdjslk4uzZs/T29t7Ue8jlcpRKJatWrSI7O5vo6Oibep9l6VeQwoZDQ0NERkYu+3RwqcAiNjaWpKQkABISEq55/Pb19V32Td7Hx4fIyEhsNpswyitXrmTFihXLtoaXX36ZZ555Rvy/oKCAb33rWxQWFuLv7y8GH9vtdhwOB/Pz87z++ut3xNTwhoYGqquraWho8BrHJcBisTA6Osrvfvc7ysvLaWtrE6HUqKgoYmJiKCgoIDo6mujoaHJzc4mLixOV1FI1ta+vL3q93uOtUr/97W85e/YsXV1dIp+ZnJzMV77yFZKTk6+4RpcyIjQ0NERdXR0/+9nPMJvNJCUl8a1vfYsdO3aIEPL27dtFqN9qtTI+Po6/vz8xMTHApf1AGkDsyb+V2+3mV7/6lSicW/i4zWa7ofdSq9UEBwfT398vogRJSUnLvr/DpT07KCiI++67j8zMTJKSkli7di1hYWE3vT8tqXH08fEhOjqagYEBRkZG+MMf/kBpaamorFwuA+R2u5mZmcFgMDA4OEhgYCDh4eF3XCWir68vZrNZFONIbRrLhdlsZmxsTPxfoVAQGxuLv78/MzMzmM1mBgcHmZiYwGg0MjIyQkVFBTKZjObmZs6ePStEHaTWidjYWCIiIpZ87WNjY4yOjjI5OXmFcQwODha5x8vzppKD5HK50Gg0REVFERsbS2FhocfyuH/pmEwmOjo6qKmp4dSpU6JobGG+Oz09HZ1OR0hICCEhISIceLWN0lObp8PhwGg0UldXR11dHYODg9hsNvz8/EhJSaGoqAitVktAQMCypXKsVivt7e2Ul5czOTlJSkoKa9euZe3atWg0GnECXHhqdTgcaDQascEvFTabDaPRSGVlpcivh4aGEhwcjNvtFiFSf39/lEolarWasLAwIiIi0Ol0+Pr6LnIqQkNDCQgI4OTJk/j6+hIXF8euXbtuOSIgnVwXFtWsW7eO1NRUIiMj6e/vX1T1nJKSgk6nIyAggJUrV6LVaomIiECr1d7SHr+kxtHX15eUlBRaW1vp6uri17/+NfPz86xatYqCggLUajW+vr5LduFKnqrT6cRkMtHU1IRSqSQqKoqMjAwUCoWITy8svpFOSbeD8fFxhoeHxWlXLpczPz/P/Pw8cMnhkNYn/VsqpBCHyWSiv7+fvr4+4FIIq6enh/r6+qv+XEBAAEVFRRw4cICVK1eK6uSl/K4nJiaYnJxkenr6iuckkQmr1SqMo3SjS2FAhULBihUryMvLo7i4mC9+8YvePjcQBSRnz57lyJEjVFVVoVAo0Gg0yGQy7r33XtavX09+fv6yrktyeLu6unjllVdoaWkROeLAwEDy8/O56667UKlU4oS2HN+nyWSivr6esrIyXC4XxcXFbNu2jczMzGv+jJ+f37I4wTMzM3R0dFBdXc3Q0BC+vr4kJCSg1Wqx2WwMDQ3h4+NDaGgocXFxpKSkkJycTEpKChs3bsTPz2+RcZQMeVBQEAqFAp1Ox2c+85klWXtpaSn79u0jOzub06dP09nZSXt7OwB79+7lrrvuIigoyKPf8ZIaR4VCwcMPP8z4+DhGo5HOzk7+/d//nejoaLKzs/n2t79NcnIykZGRHi/ekMlkbN26VRRpTE1N8dOf/lRsivn5+aJSLD8/n8jISOHN7d+/n5iYmNtysuzv7xehoY6ODhQKBSMjIxw6dAi32014eDh79uwhMTGR6Oho4uPjl2wtNTU1fO5znwMubUZSkcvlOYnLsVqtfPzxx1RVVaHRaMjPz+ef/umfyMnJQafTLclazWYzVqv1quEyq9WKj48PNptNhK81Gg2hoaFERUWRlpbG3XffTVxcHBqNhrCwMK9h5FKf4vDwMN/+9rdpaGhgZGQEtVrND37wA3bv3o1MJlt0GlouXC4Xk5OTHDt2jPLycl5++WVRPyCXy9m4cSOlpaVkZ2djMpkYGxtDpVJ5pF3kerjdbt577z0+/PBD6uvrcbvdlJaWsn379iX93E9LR0cH//Zv/8bw8DA2m43Q0FCefPJJwsPD6e/vp6mpCZVKxb59+3jyySeJjo4W++XV7gfpXvuXf/mXW2qZuNb7Lny/w4cPU1FRgVqtFvu5xWJBJpPx0UcfkZuby3/9138RGRnpsetxycOqsbGxPPDAA+h0Ot544w3a29sZGxujrq6OH/7wh8THx5OYmMjOnTvJyMjwmAclk8lIS0sjPj6e4OBgpqenRQIcLvW9SZ5Qf38/AQEBIrb/8ccfEx8fj16vFzlSlUpFaWnpFaEFT7PQ6FRWVtLW1oZKpaKnpwe4dKrt7OwUpeibNm3innvu8Uh7zLZt27BarTz77LPisYV5CIVCwc6dO6/7+w8PDzM8PEx3dzd2u53JyUnq6uo4fPgwPj4+S2Ic3W4377zzDnV1dVe9iS8/TU5PTzM/P8/Y2BirV6+muLiYvLw8lEolCoXijgu33w4mJyfp6Ojg8OHDtLS0IJfLKSkp4aGHHqK0tFSIKPj7+y+rHqkUzXjttdf44IMPaGpqWlRY53A4qK2txWg0cuTIEdRqNSaTiYCAABISEsjIyKC4uJjs7GyPr9vtdtPX14fRaMTHx4ekpCQiIyPviJw8XHISh4aGhJPrcDhoaGhg8+bNFBUV8cMf/pBXXnlFFFxptdpPle/0ZE50YmKC48ePX1GVbzAYMBqN+Pv7YzabsdlsQlShr68Pq9XKL37xC770pS95TIZ0yQtygoKCKCoqIiwsTOQpxsbGmJmZ4fTp06jValFq7XK5SExMRKPR3HJeQiaTER8fT3p6Orm5uXR0dCxS7FiojjE6OrroZ9va2oiJiSE9PZ3Y2FgUCgVhYWFoNBpRZbdUvZqzs7Oi6bW3t1c0DgcEBOB2u5mdnaWhoQGr1UpnZycul4tNmzZ5ZJPKzc3Fx8eH8+fPMzY2JkK5wcHBBAQEEBoayo4dO65rPPr6+ujv70ej0TA2NobJZGJ4eJjKykqSk5NJTU31eJGRJBU4MDBw1bVJv4f0nNVqFS0d0nNSb6tXePoS/f391NXVcfz4cUZGRoiOjkalUhEbG4vNZmNsbIyQkBCh+LJcJ22j0cjFixc5ceKE6LFciNvtZmBggOHhYVGRarFYUCgUhIeHU1hYiJ+fn+hr9DQWi0VEKoKDg/H19RXKN76+viLEeznS4w6Hg8DAwCVJQchkskUpI8k4JiYmila3mpoa1Gr1DRfneAqLxUJjY+MVnz89Pb3IyV14iLDb7czPz3Py5Enuv/9+9Hq9R+7jZalWDQ8PJzw8nIKCAt5++23q6uqorq6mpqZGFIFIHsyGDRv4h3/4B2JjY2/Zg4+Li+PgwYOsX7+e5557jp6eHsbGxpicnGR4ePiaTcIWi4XOzk46OzvFYwqFgvLych599FGKi4tJTU29pbVdi+bmZi5cuCD+L1UBpqWliX6oixcvUlVVRXd3N4cOHeKf//mfCQgIuGWDHR8fT3x8PDt27ODFF1+kq6sLmUzG2rVrSUtLu+Gw1G9/+1uOHTvGoUOHaGhoYHp6mpqaGv7whz/cMaez559/nvb2duLj4ykoKLit+rR3EmVlZRw7doy6ujrgkqPW29vL0aNH2bx5M6tXr2bz5s1Cq9aTbRnXo7a2lrfeeot33nnnuqF9yQmWnCCr1crU1BTd3d1MTk4yNDTEU0895XFnSIo+SNKZAwMDdHd3o1AoCA4OFvfw1dY7MzOD0WgkPz+f0NBQj584IyMj2b59O8PDw5hMJubn5zlx4gQ1NTVotVpWr17Nl770JVasWCEiA8vN/Pw8BoPhmn3K18LpdDI4OMjU1BRWq9UjvbPLOnrCz8+Pbdu2cdddd4nq0fPnz1NVVcVrr71GZWWlCEk88cQTHgmxSqW83/ve97Db7czOzjI5OYnBYMBut+NyuWhtbWVgYICBgQFqa2sJCQnBarUuqty02WzU1NTw9NNPs2XLFpG/9DQL5asKCgrYs2cPDz/8sDg5SqXfr7zyCh999BHl5eW8++67bN682aNFEXv37mV+fh6ZTEZgYOBNGd79+/ejVqvp7OykoaGBoaEhzp8/z/nz5z2quyqTybjnnnv4+OOPaWpquqGftdvtWK3W2+Yp32m4XC7MZjMKhYLIyEj0ej1DQ0Oi8Vomk1FdXU1LSwtvvfUW+/fvF0MElgOj0XjN/rfo6Gj0ej0lJSUkJycLwQ+pEOXEiRM0NDTQ09NDRUUFTU1N6PV6j1WI+vj4cO+992IymWhsbGRoaIinn35avL9Go8Fms2E2m4VRXmjgpbx+amoq27ZtY8uWLR69p/V6PU8++SR33303HR0dNDc389ZbbzE7O0t3d7cQBsjJyWH9+vUcOHBAFC3e6TgcDsbHxzl16hQ+Pj5s3rz5lt9z2ecyhYaGCimk6OhoAgMDCQ0NFdVH4+PjjI2N3bDncC0k1QnJC5MkkJKSkoTkUEJCAqOjo4yOjpKRkUFQUBAmk4nOzk5hrMxmMyMjI3R3d1NVVcUbb7xBbm4u0dHRHmlVkKrvJE83LCyMzZs3s27duitObG63m/T0dKEgUV9fT1ZW1i2vYSGeGDodHh5OdnY2n/3sZzGZTIyOjjI+Ps6bb77Jvn37yMrK8sh4IJlMRkFBASaTiampKQYGBnC5XMjlcsLDwxkfH8fhcFw1nCXN/PSU5NRfOlKYNCsrC6VSSVJSEhMTE4uiLD09PQwNDdHe3s6ZM2cIDAwkOzubxMTEJQ+vxsTEkJeXR1VVlajojouLIyEhgdjYWHQ6HTk5OcTGxgrn2mq1EhoaSk9PD83NzZhMJi5evMiZM2cIDQ31aPtEUlISxcXFDAwMUFFRwczMDFNTU5jNZqG8I+1tknACIHJokoCAWq0mIiKCvLw8jxknhUKBVqsVrVZSOPXixYsMDAzQ399Pe3s7FouF6elpUaym1WqXJW86NTWFwWCgp6dHiBHAn8PBKpVK5I2lAk6TyURLSwu9vb1YrVa6uro81oJ1W4cWqlQqVq5ciV6vx2Aw8Nvf/vaaqjWewtfXd5GBBkQOzOVyMTs7i6+vL0NDQ9TU1NDb20tXVxednZ1C97Suro6nnnqKr33ta2zYsMEjxtHlcgkpM6mK8u///u9JT0+/4rUymYyYmBghFlBXV8fGjRtveQ1LQVpaGk899RS1tbWcO3eOnp4efvzjHxMcHCz6TT3BqlWrRChNMoYhISHk5ORQXV0txiTBJQdp4XUmTRXxGshL15ZKpWLLli3XfM3hw4c5duwY7e3tVFRUiDF0cXFxSx6Wzs/PR6VS8cc//hE/Pz9iY2PZtm0bu3fvJiIi4ppSYTabjeTkZGQyGSaTCavVyqFDhygqKvKofm5UVBTbt28nPj4es9nM/Pw8FouFixcvEhgYSEhICMHBwVes0WQyYbFYhNhCfX09wcHBHDx40OMnt8jISCIjI8nLy2Pv3r2cOnWKqqoqjhw5QmNjI+3t7aIi9IEHHmDTpk0enbV7LYaHh+no6ODChQuLnDFpz05KSmL//v088sgjREVF4Xa7aWpq4plnnuGtt97CarXS09MjWs5ulds+0Vcam1JWVsbExITHBXZvBB8fH9HOodfr0el0i0bg1NbWigt+aGiIY8eOERERQXFx8S1/tq+vLzqdjueeew6Hw4GPj49IzF+N3Nxcuru7CQ4OFnH2OxWZTEZRUZHwCuFS0VNSUhIrV670yGfk5+eTkZHBZz/7WWpqanC5XEKxo7u7W+R5LBYLb775JidPnhRiCwaDgUOHDlFYWHjbRPH/kli3bh1yuZzDhw9fMTB4qZmcnMRisVBWViZaDPz8/JDL5dc9tVosFnp6ehY5QEulpKTVaomOjmbt2rU4HA4sFgvd3d1ER0cTHBx81fzs1NQU58+f54UXXuD48eNLsq5rUVpaSklJCY8//jhVVVUcO3aMl156iZMnT9LV1cXJkyd5/vnnkcvlSxpi1ev1bNq0ia997Wv85je/YWpqCn9/fzZv3sy+ffsoLi4mJydH3KMymYysrCxSUlKIjY1lbGyM6upqYmNjPbKe22Ic3W43DoeDxsZGmpqaaGhooL29ncDAQPR6PXl5eUvigUoh0sHBQXJzc6/bW7mwwd5oNC4amwJ/Pm14KvwrfeanDfGoVCqioqJISkpicHBQqP/czFDP5eDyikYphHSjSFqUVVVVBAUFERkZSXp6Or6+viiVSuRyOXl5ecAlhyMkJITAwEDxecePHxetHJJqjlqtFhJ5Xj4ZqUk8MzOT2traJf88i8VCX18fr7/+Ok6nE41Gw4YNGz51CLe/v5+WlhZqa2uF46lWq3nooYc8tpEuRApNS8oz0mxQaS7j1SrxpWra2yG95ufnh5+fHwEBAWRnZwshgLfeeguj0Uh9fT2HDh1ix44dS1qoI5fL0Wq17Nu3D6VSicViwd/fnzVr1ojOgcv3bGmfloy2w+Hw2J68bMbR4XCIuVtS6W15eTkfffQRtbW1jIyMUFhYSE5ODrm5uUtykRgMBrq7u6mvryc+Pv4TW0acTieTk5N0dnbS0tJyxWy4pWzp+CSkGHxUVBSdnZ1MTk4yPj5+xxpHT2C1WpmcnGRgYICjR48SERFBSkoKUVFRQgVHusEWolQqRa65u7ub0dFR0cIBl77HrKys27Ix3alYrVYcDocoyFp4YggICCAsLAydTkdjY+M1B2F7CqPRyLlz53juueeIi4sTwwM+CWnwwYULF6iurhatT5JTtWPHjiUfLiDlyz7JqEhG83brAsfExIjc3sjICKdPn2ZgYIB3332XzMxMVCrVks3ilclkhIWFsWbNGlG85OvrS1pa2jVPrfPz89hstiVJxy2LcbTb7QwODvK73/2OEydOMDk5id1uFwUlUp7jscceY/PmzUIc3NO88sorHD16lAsXLhATE8PatWtJSUm56mttNhsmk4kf/ehHlJeX09TUtGgDkMlk7Nmzh4KCgiVZ6ychVd4ajUbhqf41n3zcbjc1NTUcP36cU6dOUVFRga+vL6mpqfT09PD4449fNyQ/OjpKbW0tv//97xdVIXu5OjU1NWKI9fbt268a0ZDCmjMzM3R3d3s0irKQtrY2/vM//5PR0dEb0mSenZ2lurqab3/72zQ3NwvHVqfTUVxc7JF+ak9ys9EUT6NSqVixYgXf/OY3AXjjjTd45513SElJwWw2e6QS9FpIzsT15PYkXC4X9fX1otvA03wq4+hwOBgdHeUXv/gFBoMBlUrFZz7zGWJjY69Zjj88PExvby8Gg0F4bT09PZhMJnECk4R24+LiRHGLpEq/FEihUJvNxs9//nNOnz7NXXfdxYMPPiiaTKempujp6RHFBrW1tcKYX46fn99t69drbW3lwoULtLW1CaHnmx0Tcy0GBwcpKysjKyuL+Pj4mwpB9fX1UVZWxgsvvEB/f794XK/XX9MxuRp2u53vfve74hqSyt57e3t54YUX+PznP39d43jx4kVeffVVjEbjkhd9/SUzMzPDoUOHePvttwkLC+MnP/nJFSeFrq4uqqqq+PDDD5mamqKgoIB169Z5fNKGhKR9C5cqZcvKyvjZz34mHOng4GDkcrlI18zOzor74ze/+Q29vb3CMKrVajZt2sSDDz4o9H7vBAwGA62trXz88ce43W5SUlIoKSm55Rzf+Pg4//qv/4qfn58QHk9LS6O0tJQNGzZcM7UkFf1t3boVp9PJr3/9az766CPUavWSGken08nc3Bx9fX2EhYVdd89xOp28//77NDc3X3UQ+63yqa5mKbxYU1NDe3s7CoUCpVJJTEzMNXsRx8bG6O/vZ3h4mAsXLmAwGFAoFMTFxeHr64vdbicmJobIyEgSExPZtGmTUNBfKhaqvTc1NTEzM8PMzAxRUVFCYHtiYkLom9bV1V0x6R4uhUAkxZzlnnYv0dLSQmtrK9PT02i1WpFb8yRjY2McP34cHx8flErlDRtHs9lMZ2cnH3zwAZ2dnUL7NCwsjMTExBsKAUsqOOPj44s2DClUWlFRcUXvpM1mw2AwYDabOXfuHHV1dczPzy/yzlNSUkhNTSUiIsKrp8qlMNXHH39MXV0dK1asICAg4Iq/d29vL21tbYyMjCCXywkODkar1S7Z3y80NJTc3Fx6e3vFxvnhhx8yNzfHihUriI2NJTAwUPQAS20mzc3Ni/KM/v7+5OXlUVhYSGZm5h1hGF0uFxaLhaqqKmpqahgfHyc+Pp60tDSPSNw5HA76+/sZGhrCYrEwMzNDXFwcLpfrE99byoNqNBrcbje9vb1Cqm0p9umJiQnGxsbo6uqitbWVqKgoUlJSxND5hQ6x1WrFbrdTUVHB0NCQOLwkJSV5TKLyUxtHk8nE3NwcRqMRs9nMT37yk0/9IVI/UnJyMg899BAqlQqz2cy6detISUlZ0tPitbBarbS2ttLR0cH58+eZnp4W0+2vh0wmQ61WU1xcTG5u7m1ZO8DJkyepqKgQY8GWwkgPDQ3x6quvEhkZSUxMzA3drJJw+p/+9Cdee+018bi/vz/5+fnk5ubesOLOwr6whTgcDp5++mmhkyoxPj7Oe++9R21tLTMzM1dd+7333sv27ds93if6l8r8/DwVFRWi3aGvr4+UlBTkcrmYbl9XV8eFCxeQyWSEhoYSFhYmpOSWgqSkJB555BGqq6sZGBjAZDJx/Phxjh8/TkhICFlZWURFRQnd1crKykW5O5lMJkQNvvCFL7Bu3TqioqKWZK03gtvtZm5ujvb2dp555hnq6urw8/Nj1apVrF+/3iNV8P7+/qxcuZLm5maGhoZQq9Xs3buX7OzsT1UvYTabRYvZ8PAw/f39jI2NLRoe7Snq6+v56KOPeOONN4RxTE9PZ/v27aJ4zmKx8Nxzzy2SDVx43e3evZtt27Z5ZD2fyjgqlUpWr17N97//fZqamqisrOT111//xPYBqT1h586drFmzhvXr1xMREYGfnx8ulwuFQrFkoZiroVQqrzhdSZ6I1Ax+PRQKBbt27WLjxo08+OCD4ne5UWw2m5CzutGZY/Pz87S3t4sRPRkZGfzkJz9Z0j6k559/no6ODlpbWykqKiI9Pf26vZ2Tk5O88MILvPTSS3R1dYnHJYm23/zmNzcsMuDr68vDDz9MWVkZNTU1Vzzf1NREZ2cnb775pnhMkg+TlH6km0gul+Pv7094eDg7d+5k3bp1N7SWv3ak6MrY2Bhvv/02W7Zsoa+vj4qKCsrKyhgdHWVqagq3283LL79McXExISEhS3pyXLlyJd///vd54403OHLkCDMzM7jdbqanp6mtrV2kOHP5fbx//34hf3jfffctm9TdJ3H27FnKy8v5+c9/jslkQqPRsHPnTn70ox95bNpOaGgoX/7yl1Gr1Zw+fZr333+f119/nenpaTZv3nzNv4XL5aK5uZn333+fd999F7i0b0nFL0vRE/zhhx9SVlZGa2srdrud4eFh0Z4Bf1YTkhxdSbEJLt3TERER7Nixg7vuussj6/lUO7uUJE1PTyc8PBydTkdKSsonVqj5+PgQHh5OZmYmiYmJxMfHL3mvzPXIyMjAYDDQ1taGyWQS4bVP+j2Cg4PRaDRs3bqVDRs2kJ2dTWRk5E1vBmNjY7S1tVFWVsa9996LTqcjMjLyE42kpNf4zjvvMDAwgEKhICMjQ0we8TTh4eGUlpZSVVVFc3Mzdrud2tpaoqOjiYmJobCwELgUapPC6HDp4q2srKS7u1tI4cXHx7N161Z27twplEJuBB8fH4qKioQgw8LWGpfLJW7chc3+EtJNJQ1kTUxMRKfTUVhYSGpqqre3cQEKhYL169djsViYmJjgww8/pLu7m4mJCXp6eujt7UWtVpOTk0NhYSEZGRkeUVO6HpLKVWFhIb6+vmRmZnLx4kWamprEtIb5+XnxPQcHB5OZmSnSAPfeey+JiYliePjtDKdOT08zOjrK2bNnOXfuHPX19QwPD6NSqUhNTeXAgQPEx8d7LEXi6+tLREQEJSUlyOVypqamqKurw2q1YjAYuP/++wkJCRGRgbm5Obq6ujh//jxtbW1UV1eLocJ6vR69Xo9KpVqSPdxqtYpuBvizPq7k3F6O9Jg0YDs2NnbR6MFb5YaOPTExMcTExJCbm7tsWoqeJDc3l/n5ec6fP09XVxczMzNX5KAA0VDs7+8vJJfS0tJ49NFHSUtLu2XNV6l36PnnnyckJISioiIyMzOFgZSqABdeENLG39vby+HDhzEajSQmJlJYWIhKpVqSE3h0dDR79+6lq6uLkZGRRbH9mJgY/u7v/g64VAna0dHBuXPnrvDapd7N/Px8du/ezQMPPHBTa5HJZOTk5NDQ0CDC4ZL83yfh6+uLXC4nJCSE/Px8Vq1axapVq7jnnntuai1/zSiVSnbs2CGUSiorKzl37hxOpxO3201gYCAZGRkUFRXx0EMPLUt4UqrGXrFiBStWrGD37t1UVlby3nvv0dDQwMWLFzGbzTidTpFm2Lp1q3DetmzZQnh4+G1xyu12Ow6HA5vNyeSTEgAABZ5JREFUhsvlYnBwkMbGRv73f/+Xjo4OJiYm8Pf3JzY2loKCAu6//36PV50rFAry8vIICQlhfn6eX/7ylwwODtLc3ExWVhY6nY7AwEDm5uYYHx/nj3/8Iy+++CL9/f3Mzc3hdDpRqVQUFRVRUFAg2qY8zY3MhFw4mF6SDYyLi0OtVntsL5R9wvH4r05PS2rROHr0KKdOneL48eOMjo4uChNkZ2eTmprK6tWrueeeewgLC0OlUnnsBnM6ndTU1PDTn/6UI0eOIJPJ0Gq1/PjHPyY+Ph61Wi0k7nx8fHA4HJw5c4YjR45w5swZqqqq2LBhA7t27eLrX//6kpajOxwO/ud//ofGxkba2tqoqKgQzy38W1zrOkpPT+fAgQN8/etf90joTTr5/8d//ActLS0YjUYhig1c9VQQFhbGpk2beOSRRygsLBQjuG7hu7zzlZivzqe6n6Xii4aGBl599VV8fHyYnJzEbDbz1a9+lbVr16LT6a5w4JYTKXw6NzeHwWBgZmZGFJmEhYUREREh8vC3s9CqqqqKxsZG/vSnPzEyMoLBYKC3t5fp6WmcTieBgYHk5uby5JNPsnLlyhuq4L5RpL/Z22+/zdtvv83//d//4Xa70ev1BAcHMz4+Tn9/vzgwuFwuIiMjiY+PZ8+ePRw8eJDExMQli7R8//vfp6ysjNraWqxW66JDy+XXmVwuR6lUUlJSwsGDB9m+fTthYWE3GxW46kX8N2ccpXJvg8HA2NgYBoPhiokMkv5hWFgYMTEx+Pv7i9OHpxgZGaGyspKf/vSndHV1YTKZyMvLW6Q5Kn3ZDoeD8+fPMzQ0xPT0NJGRkTzyyCOsWbOGNWvWeGxN16Kzs5OpqSmMRiNnz56lr6+PixcvcurUKfEamUxGeno68fHxxMTEkJqail6vJzo6moSEBFJTUz3i0c3PzzM9PU1LSwtVVVU0NTVRUVFBV1cXNpsNhUJBfn4+w8PDOJ1OsrOzKSkpEe0GoaGhnpg/+FdtHAHm5uYwm81Cp9Jut2O320lJSSE8PHzJGsFvFKlCVcqDyWQykVO+E6pRf/CDH1BWVkZPT4+YIzo7O4uPjw96vZ6srCwef/xxMjIyUKvVy1L9PjQ0xMWLF7lw4QK//OUvhWLU/Py8OCnKZDKioqK4//772bx586IT5lI5RC0tLXR2doo5ndKwgP7+fmw2G9PT03R1dXH33Xej0+nQarWUlJSIfeYW9uer/kK3XVt1uZFuHp1OtyRT6T8tarWaoqIiNm3aRGxsLIODgwAid+Lr64vL5cLPz0+M1oqOjiYxMZGsrCzWrFmzpF7mQqTPcTgcaDQauru7aWtrW+RU+Pj4kJOTQ1JSEvHx8WRmZpKWlubxm12hUKBQKCgtLSU0NJT4+HgCAgKIjY3Fbrcjl8tZs2YNAwMDOBwOCgsLWb9+vcjrevl0KJVKlEol0dHRt3sp10XSIL5TkU7gk5OTQqJNo9Gg0+nIzc1l5cqVbNq0aVkNuVarFUPmKyoquHDhAqOjoyiVSkJDQ/H39ycoKIiMjAy2bNnCpk2bPDYg4HpkZmai1WqJiIgQxlEqmJScNa1Wy/bt20lKSkKr1ZKdnb1kf7u/uZOjFy8e4K/+5OjFMzz66KMcPnyYiYkJQkJCSE1NZe3atXzxi19Er9cveTHT9ZD0rd99911aW1uBPw88T0lJYfv27cvaTXAb8YZVvXjxEF7j6OVTYTAYRH5RKvJTKpWo1Wr8/f1vu/CE1WrFYrEIrWG5XC6kKD1V9fkXgNc4evHiIbzG0YuXvx6uej979bK8ePHixYuXy/ikgPJfqofsxYuXK/Hez168fEq8J0cvXrx48eLlMrzG0YsXL168eLkMr3H04sWLFy9eLsNrHL148eLFi5fL8BpHL168ePHi5TK8xtGLFy9evHi5jP8Hb3lyWIRq3MMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制图片\n",
    "def plot_digits(instances, images_per_row=10, **options):\n",
    "    size = 28\n",
    "    images_per_row = min(len(instances), images_per_row)\n",
    "    images = [instance.reshape(size,size) for instance in instances]\n",
    "    n_rows = (len(instances) - 1) // images_per_row + 1\n",
    "    row_images = []\n",
    "    n_empty = n_rows * images_per_row - len(instances)\n",
    "    images.append(np.zeros((size, size * n_empty)))\n",
    "    for row in range(n_rows):\n",
    "        rimages = images[row * images_per_row : (row + 1) * images_per_row]\n",
    "        row_images.append(np.concatenate(rimages, axis=1))\n",
    "    image = np.concatenate(row_images, axis=0)\n",
    "    plt.imshow(image, cmap = matplotlib.cm.binary, **options)\n",
    "    plt.axis(\"off\")\n",
    "\n",
    "\n",
    "# 查看数字3和数字5的例子\n",
    "cl_a, cl_b = 3, 5\n",
    "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n",
    "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]\n",
    "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
    "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.subplot(221); \n",
    "plot_digits(X_aa[:25], images_per_row=5)\n",
    "plt.subplot(222); \n",
    "plot_digits(X_ab[:25], images_per_row=5)\n",
    "plt.subplot(223);\n",
    "plot_digits(X_ba[:25], images_per_row=5)\n",
    "plt.subplot(224); \n",
    "plot_digits(X_bb[:25], images_per_row=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "* 左侧两个是被分类为3的图片\n",
    "* 右侧两个是被分类为5的图片\n",
    "* 大多数错误分类的图片看起来还是非常明显的错误\n",
    "* 原因：SGD是一个线性模型，它所做就是为每个像素分配一个各个类别的权重，当它看到新的图像，将加权后的像素强度汇总，从而得到一个分数进行分类\n",
    "* 数字3和5在一部分像素位上有区别，所以分类器很容易将其弄混\n",
    "* 通过上面图像，如果书写3 的连接点左移，分类器可能将其分类为数字5，这个分类器对图像位移和旋转敏感\n",
    "* 减少混淆的方法之一，就是对图像进行预处理，确保位于中心位置并且没有旋转"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多标签分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "# 7 8 9 三张\n",
    "y_train_large = (y_train >= 7)\n",
    "#奇数\n",
    "y_train_odd = (y_train % 2 == 1)\n",
    "# 合成综合数据\n",
    "y_multilabel = np.c_[y_train_large, y_train_odd]\n",
    "# 算出距离\n",
    "knn_clf = KNeighborsClassifier()\n",
    "knn_clf.fit(X_train, y_multilabel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# knn支持多标签分类，不是所有的分类器都支持\n",
    "knn_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多输出分类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 例子：构建一个系统去除图片中的噪声，输入一张有噪声的图片，它将输入一张干净的数字图片，分类器输出是多个标签，一个像素一个标签，每个标签多个值0到255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 增加噪声，目标将图片还原为原始图片 创建训练集和测试集\n",
    "# 初始化 噪声 训练数据\n",
    "noise = np.random.randint(0, 100, (len(X_train), 784))\n",
    "# 加到像素\n",
    "X_train_mod = X_train + noise\n",
    "\n",
    "# 测试数据\n",
    "noise = np.random.randint(0, 100, (len(X_test), 784))\n",
    "X_test_mod = X_test + noise\n",
    "y_train_mod = X_train\n",
    "y_test_mod = X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAC2CAYAAAD5uGd5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAZxUlEQVR4nO3de4zU1dkH8O+zyy7gcnG5CHJVFAto2QpbLgoVq9WiNmkxjSa1l7QpTZrYNOkffS20idTXtG9a+yZNSkriWxua2thGLYnBipYKREEWDTcRBFzkfmcR2HVh93n/YFbZOd8Ds7M7w57h+0mMzMMz8/v9Zs4efjvnPOeYu0NERNJRdrlPQEREOkYdt4hIYtRxi4gkRh23iEhi1HGLiCRGHbeISGLUcYuIJKZHvk80s6cBTADwkrs/EcsbOHCgjxo1ql0sNne8paUliJ09e5bmlpeXB7HW1laay45XVVVFc8+dOxfEmpubaW7v3r2DGLsGgJ/vqVOncnrN2OuaGc39+OOPg1ifPn1yfl32fADo1atXEIu9N+x9vOqqq2guu47YtWWf7+7du3Hs2DGenIdc2zUADBo0yK+77rquOrRIO/X19Thy5Aht23l13GY2B0C5u083s/8zs7Hu/j7LHTVqFF5//fV2sVjHcPLkySB28OBBmtuvX78gxjpCgHci06ZNo7mHDx8OYh9++CHNveWWW4JYQ0MDzb366quD2KpVq4JYTU0Nff7x48eDWEVFBc3dsWNHELvttttoLnvPd+7cSXM/85nPBLE9e/bQXPY+Tpo0ieb26BE2w549e9Lc7Pf33nvvpXn56Ei7BoDrrrsOdXV1XXZ8kQvV1tZG/y7fr0pmAXgu8+dXAMy48C/NbK6Z1ZlZ3dGjR/M8hEjRzcJF2jXQvm2zf5xEiiHfjrsKwN7Mn48BGHLhX7r7InevdffagQMHdub8RIrpou0aaN+2Bw8eXNSTE2mT73fcpwC0fRnbBxf5B+DcuXPBr83Hjh2juadPnw5i1157Lc1l3wWzX+UB/lXHu+++S3PZ1x8ffPBBzucQ+272zJkzQYz9KsS+RwaApqamIJY9dtCGnS97PgBs27YtiPXt25fm7t27N4jFrveaa64JYmVlvJmwsYnYb2rZX3t18Vo7Obdrkcsp34a5Dp/+GlkDoL5Lzkbk8lK7liTke8f9IoCVZjYMwGwAfKRPJC1q15KEvO643f0kzg/krAZwp7vzqRQiCVG7llTkPY/b3Y/j0xF4kZKgdi0p0OCLiEhi8r7jzlXPnj0xZsyYdrHhw4fTXFbMwQptAKCysjKIvffeezSXFeAMGRLM9IqKVcdt3LgxiE2cOJHmrlixIoh9+ctfDmLvvPMOfT4rtlmzZg3NnTJlShCLzeiYMGFCEIsVPbFZP7HKVnYObAYLwIuW2OweAGhsbGz3ODarRaSU6Y5bRCQx6rhFRBKjjltEJDHquEVEElPwwcmmpiZs2bKlXSw22Ddo0KAgxkrFAeDQoUNB7Oabb6a5778fLvDGng/wATi2sh/AV9Zjq/gBAFuzZdOmTUFs/Pjx9PkfffRREBs6dCjN3bx5cxCLrcz39ttvB7Hbb78951w2uAnwgchYiT4rW2fvDQBMnTq13WO2sqBIqdMdt4hIYtRxi4gkRh23iEhi1HGLiCRGHbeISGIKPiRvZkG5NtsTEQBGjhwZxGJ7GrKNZ1lZOcA3ys0uw2/DSrjZ7BGAz46JbULA9tlkz8+egdOG7acZ2xyBlcezGSEAcMcddwSx2PUOGDAgiJ04cYLmVldXBzE2YwfgGw6zYwHAunXr2j2OzToSKWW64xYRSYw6bhGRxKjjFhFJjDpuEZHEdHhw0sx6ANiZ+Q8AHnX3cGHqjMrKymDQMTagtW/fviCWvf7yBecRxGLlzyweK2Nn5eKxQTW2A/3y5ctpbq5rZLNBPYAP4N16660099ixY0Es9t5s3bo151w2IMx2cweAXbt2BTE2wArwkveWlpaczqEr1+PuaNsWuVzymVUyEcCz7v7Trj4ZkctMbVuSkM9XJdMAPGBmb5nZ05m7FJFSoLYtScin414L4G53nwKgAsB9XXtKIpeN2rYkIZ87ig3u3lZNUgdgbHaCmc0FMBfgRTUi3VSH2nZsmVqRQsvnjnuxmdWYWTmArwJYn53g7ovcvdbdawcPHtzpkxQpErVtSUI+d9wLAPwVgAFY4u6vXiz59OnTqKuraxeL7eDNSq1Hjx5Nc9kPDdv5HQDefffdIBYrj2c7wn/hC1+guWz2Bis3B/iMGTYrJbYTOiulZ+cK8F3a2UYMAJ8pwja0AICqqqog1traSnN79+4dxGIbaLBy/CFDhtDc7B3h2YyUTuhQ2xa5XDrccbv7JpwffRcpKWrbkgoV4IiIJEYdt4hIYtRxi4gkpuAFBj169AgGu9avDwbrAQA1NTVBjA1yAXzdbFa+DQD9+/cPYrFSbTZAGhswvP7663OKAXzt7L179wax2PWy8vadO3eSTH6sz372szSXDTjGSt7Z2tcbN+ZeEc4GiQHg3nvvDWKxgdd+/fq1exwbkBbprOeff57G58yZE8Ri6+iPHz++S8+pje64RUQSo45bRCQx6rhFRBKjjltEJDHquEVEElPwWSVlZWVBWfVNN91Ecw8cOBDE2KwHgJdwxzZHYKXpsbJuVsIdK6tms1hWr15Nc7N3JweAESNGBLGlS5fS50+bNi2Isd3rAeDll18OYvX19TSXbW4wcOBAmstK6WMzUIYPH07jDJtJE5sF8+ijj7Z7/PHHH9M86Xq/+93vaDw2myvbCy+8QOPjxo0LYrHZGK+//nrOx2c/t7GNNzqbG5ulNmDAgJxz2bXF6I5bRCQx6rhFRBKjjltEJDHquEVEElOUkvfstbNja0PfcMMNQWzPnj00l33pH9sZnA107Nixg+aywbbYTie//e1vg9gTTzxBc4cOHRrEevXqRXMZtvv82rVraS57H2PrhI8ZMyaIsbXDAT74y5YpAHiJ/u23305zZ86cGcRiywzceOON7R737NmT5knnsHLvn/zkJzSXDeJ1ZLBv5cqVQWzVqlU0tyOvy3RFLluf/6mnnqK5bBJEbGJER+iOW0QkMeq4RUQSo45bRCQx6rhFRBKjjltEJDE5zSoxsyEA/uHuMzOPnwYwAcBL7s6nUWScPXs22DCALfQP8IX2Y7u8l5WF/+awknmA7xgeO4fsWQsAsHv3bpp74sSJIMZ2bgf4aPiMGTOC2JEjR+jzWTy2+/xXvvKVIBa7BjbbJbYkwYQJE2icYWXzrLwe4J9lzOHDh9s9jm24kKvOtO1SxsrTY0s/MJMnT+7U8WMl72xGBiuZ7+jrsplN3dklf2LMrBrAnwFUZR7PAVDu7tMBjDGzsYU9RZHCUNuWVOVyq9MC4CEAbXt6zQLwXObPrwAIbxtF0qC2LUm6ZMft7ifdveGCUBWAtu8+jgEIvocws7lmVmdmdWxlPpHuoLNtO/trG5FiyWdw8hSAtnU4+7DXcPdF7l7r7rWswlGkm+pQ286uCBYplnxK3tfh/K+QqwHUALjoYrzNzc3YtWtXu1hsjW02+LV9+3aam73bNxAfpGAl3LFSaTZoGSsBf/bZZ4NYbE1wNljzm9/8JoitX7+ePp+VkMd2TW9sbAxiDz/8MM2NDVoyJ0+eDGKxgUU2aBhbo7uhoSGIxUrps9tSF+tQ2y4Fsd8aWMl5rAR8/vz5QWzBggWdOzG5qHw67hcBrDSzYQBmAwhX+BdJk9q2JCHnr0rcfVbm/ydxfhBnNYA7s74jFEmO2rakJq/VAd39OD4dfRcpGWrbkgJVToqIJEYdt4hIYgq+kUKvXr2C2SKxsu733nsviMXKr7N3jgeANWvW0Fw20+P48eM094033ghiy5cvp7lsBkrsfFl5+oYNG4IYmz0CAG+99VYQmzVrFs1lc+djszHY7JozZ87QXLaj+tmzZ2kum4EQ2xSDLWtQWVlJc7M34WhtbaV5EtqyZUsQmzNnDs1l7SW2AQDbIIMdK1ZuLh2nO24RkcSo4xYRSYw6bhGRxKjjFhFJTFF2ec9eryRW1s1K3llpOwC8/fbbQSy2LgpbN3vsWL5i589//vMgFluHmMVjg54/+tGPgtj1118fxJ57jk8hZtcWG4xl2G7uAB9cjK0pzgY9W1paaC4bPG5ubqa5bCCLrRMOdGyX7itVrIz9vvvuC2KxQWv2PscmFbDXHTVqVBBbu3YtfX5X7Hp+pdEdt4hIYtRxi4gkRh23iEhi1HGLiCSm4IOTTU1N2LZtW7vYXXfdRXPLy8tzfl22qe/p06dpLtss+NChQzS3rq4uiMUGMlnVHnt+LJdtnvvAAw/Q5//iF78IYt/61rdoLhsEyt6wuU12JSIQr4Zkg5axAVKWGxsgraioCGKsShMIB6vZc690H374IY2zgciObADckdz6+vogds0119Dc//znP0EsthG2nKc7bhGRxKjjFhFJjDpuEZHEqOMWEUmMOm4RkcTkNKvEzIYA+Ie7zzSzHgB2Zv4DgEfdfWPsuWVlZcGu7lu38s2z2WyGWMn70aNHg9iIESNoLtsNvW/fvjSXzWZ4//33ae6UKVOC2OOPP05z2SyLf//730HsmWeeoc//17/+FcRia1aPHDkyiPXp04fmsp3b2fMBPhNn+vTpNJeVvLP11gFg3LhxQWzlypU0N3utcLYmekd0pm2npiPLBTz44INB7LHHHsv5+StWrAhiv/rVr2jut7/97SC2dOlSmsvaypXokh23mVUD+DOAtt53IoBn3f2nhTwxkUJT25ZU5fJVSQuAhwC03ZpNA/CAmb1lZk9n7lJEUqS2LUm6ZMft7ifdveGC0FoAd7v7FAAVAIKlwcxsrpnVmVkdW1FOpDvobNuOrcInUmj5DE5ucPf9mT/XAQjKCt19kbvXunttbKlVkW6oQ2178ODBxT07kYx8fhVcbGb/DWATgK8CePKiB+jRA9XV1e1i2YOVbdjazrG1evft2xfEYmXsM2bMCGKxgbL9+/cHMTa4CQC33HJLEHvnnXdoLhvwmz17dhCbOnUqfT5bJmDZsmU0l5Ub7969m+ayNdB79ODNgq2x/Nprr9FctsxArKPbtGlTEGMb0ALhZ9HFJe8datvd1eTJk2k8tnZ6IUyaNCmI/fjHP6a5rBSetUsAOHjwYBC7Ev8BzafjXgDgrwAMwBJ3f7VrT0nkslHbliTk3HG7+6zM/zfh/Oi7SElQ25bUqABHRCQx6rhFRBKjjltEJDGXpcCAzQgB+CyNGDaSHJszzhaAb2xspLlsFgvbjR3gM1NiZehstkpHdolfuHBhEPv1r39Nc2fNmhXEXnrpJZo7bNiwIBYrN49tKMGw5QvYbBcAGD16dBCLzeTJnp0Te78lHay8/f7776e5bEf5WHl8Ke8erztuEZHEqOMWEUmMOm4RkcSo4xYRSUzBByfNLCihvvnmm2kuW2M7thb28OHDgxjbNR0AGhoaglhsPW62U3ysrJqtDRzbaZ6Vi7Pziu3QzQYR77zzTpr7z3/+M4ixtb8BYPz48TkdC+CfRWzn7iNHjgSxG264geaypQpiu7xnryteXl5O8yQdrER/wYIFNPcHP/hBEPvLX/5Cc2Ml9qVAd9wiIolRxy0ikhh13CIiiVHHLSKSGHXcIiKJKfisktbWVjQ3N7eLbd68meayHcdjMxzKysJ/cz73uc/RXFZGHtvMge2E/dFHH+V8DrFZDqtXrw5irGw/NkuDOXDgAI2zGTOxbbZuvPHGIBa7XjZjhu10D/DPbeNGvmE6+yxin2V2KXxs6QJJW2yjE/bzuXXr1kKfTrejO24RkcSo4xYRSYw6bhGRxKjjFhFJzCUHJ82sP4C/ASgHcBrAQwAWApgA4CV3f+Jizz979myw/nZsQIuVVMfWp25qasopBvCBLjbIAQAnTpwIYrEBQzYIGFtHmg0CZpdvA8Dzzz9Pn8/K2Nnu6ABfP3zEiBE0d+LEcIvFNWvW0NyOrG+8Z8+eINba2kpzhw4dGsTYQDUQfsax17yUzrZr6bgtW7bQ+Lx584LYiy++SHOvuuqqIHbPPfd07sQSlMsd9zcAPOXu9wA4AOBhAOXuPh3AGDPLfXV9ke5D7VqSdck7bnf/wwUPBwN4BMD/Zh6/AmAGAL4SlEg3pXYtKcv5O24zmw6gGsBuAHsz4WMAhpDcuWZWZ2Z1sa86RLqDjrTrTP4nbTs2N16k0HLquM1sAIDfA/gugFMAemf+qg97DXdf5O617l5bXV3dVecq0qU62q6B9m2bFVCJFMMlO24zqwTwdwCPufsuAOtw/tdIAKgBUF+wsxMpELVrSVkuJe/fAzAJwDwzmwfgTwC+aWbDAMwGMO1iT66oqAg2PXjttddoLpu9wWY9AMD69euDWPaGDW22b98exF5++WWa+8gjjwSxlpYWmss2C2AzRQDgzJkzQew73/lOENuwYQN9/t69e4PYtGn8rWezaG699Vaay2bR3HHHHTT31VdfDWKrVq2iuWyn+disAvY+sk0mgLCUvhMbKXSqXXdnTzzBJ8TMnz+/IMdjn+uTTz4ZxGIzRdhSCrFZXz/72c+C2Ne+9rVLnWLJyWVwciHOT5P6hJktAfAlAP/j7vwnTKQbU7uWlOW1yJS7HwfwXBefi8hlpXYtqVDlpIhIYtRxi4gkpuDrcbt7sGN3ZWUlzWXly+vWrcv5WJ///OdpnK0v/cEHH9DcH/7wh0EsNqWR7Sr/xhtv0FxW1s0G5QYMGECfz6aeff3rX6e53//+94NYz549ae6uXbuCWGynebZUwdq1a2kuK/2PDTix3d9jSwdkD3TH2tKVjC03AAAPPvhgEIstY8A+qz/+8Y8557p7TnkAL2NfvHgxzb0SByIZ3XGLiCRGHbeISGLUcYuIJEYdt4hIYtRxi4gkpuCzShobG4MF/2M7ePfu3TuIxWZpjB8/Pudz6NWrVxCLncOSJUuC2JAhdKE4bNu2LYiNGTOG5rJdq8eNGxfEpk+fTp9/1113BbH+/fvTXDaL5s0336S5t912WxDbv38/zWUzUO6++26ay0r0YxtSHDp0KIiNHcuXw85e1iA2U+FKxmYVAcD9998fxNh7D/D3NfZe5/oZsFktAPDLX/4yiLGfDfmU7rhFRBKjjltEJDHquEVEEqOOW0QkMQUfnKyqqgpKpWPrMrOdvW+66Saay3aEj5WLHzx4MIh98YtfpLms/Jo9H+Al77Hd1Nm612w39tgAHtslnh0fANh2cTU1NTSXrVXOSpABPmgZG0RiJfqxdc0HDhwYxNjALxC+Z/nu8l7KJk+eTOMHDhwIYosWLer08dhEgZkzZ3b6dSVOd9wiIolRxy0ikhh13CIiiVHHLSKSmEsOTppZfwB/A1AO4DSAhwBsB7Azk/Kou28s2BmKFIDataQsl1kl3wDwlLsvM7OFAP4LwLPu/tNcDnD69GmsWbOmXSxWrs5mlezYsYPmshLw1atX01y283qsXHzq1KlBrLm5meayxeJjM1AmTJgQxNjMmNh5sR3WYzuc9+vXL4jFZquwDRZiZdDsNWKzP9jMlGuvvZbmbtwY9o+sbB8IP8tz587RvBx0ql2Xirlz517uU5A8XPKrEnf/g7svyzwcDOAcgAfM7C0ze9rMCj6lUKSrqV1LynL+jtvMpgOoBrAMwN3uPgVABYD7SO5cM6szs7qGhoYuO1mRrtaRdp3J/6RtHz58uIhnKvKpnDpuMxsA4PcAvgtgg7u3VWLUAQiWcXP3Re5e6+61sV/9RS63jrZroH3bZkVGIsVwyY7bzCoB/B3AY+6+C8BiM6sxs3IAXwWwvsDnKNLl1K4lZbl8j/c9AJMAzDOzeQCWA1gMwAAscfdw1OzCA/ToEQxqsd3NAV6W3djYSHM3bNgQxCoqKmguGxhsamqiuZs3bw5ibJ1wgA+mxs5h3759QYztHs9eE+BrisfOi60JHvu1fuTIkUGMlUYDfMAxtnY3K7uur6+nuawUPrYGevbAa2yANgedatcil9MlO253XwhgYVb48cKcjkhxqF1LylSAIyKSGHXcIiKJUcctIpIYddwiIokpeHXYuXPnghkNZWX83wu22UBsoX5Wlj169Giae+bMmSC2detWmnv06NEgFtvMobKyMogNHz6c5rIF/1m5OTs+AFx99dVBLFbGzmbcVFVV0Vw2KySWyz6L2HvDdnnv27cvzWUzh2KzfrKvLTbrSKSU6Y5bRCQx6rhFRBKjjltEJDHquEVEEmNsTekuPYDZYQC7Mg8HAeD17mkr1esCuv+1jXb3y7Lak9p20lK4rmjbLnjH3e5gZnXuXlu0AxZJqV4XUNrX1pVK9X3SdXVP+qpERCQx6rhFRBJT7I57UZGPVyylel1AaV9bVyrV90nX1Q0V9TtuERHpPH1VIiKSGHXcIiKJKVrHbWZPm9mbZja/WMcsJDMbYmYrL3ic/PWZWX8zW2pmr5jZC2ZWWQrXVUil+P6obXd/Rem4zWwOgHJ3nw5gjJnRHbRTYWbVAP4MoCrzuFSu7xsAnnL3ewAcAPAwSuO6CqKEPvdPqG2noVh33LMAPJf58ysAZhTpuIXSAuAhAG07+85CCVyfu//B3ZdlHg4G8AhK4LoKaBZK7/1R205AsTruKgBtCzQfA8C38E6Eu59094YLQiV1fWY2HUA1gN0ooesqgJL63AG17VQUq+M+BaB35s99injcYimZ6zOzAQB+D+C7KKHrKpAr4f0pmWsspbZdrJNdh09/FakBUF+k4xZLSVyfmVUC+DuAx9x9F0rkugroSnh/SuIaS61tF3zrsowXAaw0s2EAZgOYVqTjFkupXN/3AEwCMM/M5gH4E4BvlsB1FUqpfO4XUyrXWFJtu2iVk5nR6i8BWOHuB4py0CIq1esr1evqKlfC+1Oq15jydankXUQkMUl9IS8iIuq4RUSSo45bRCQx6rhFRBKjjltEJDH/DxrXry0MduYtAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 随意找个图片\n",
    "some_index = 5500\n",
    "plt.subplot(121);plt.imshow(X_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.subplot(122);plt.imshow(y_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 模型训练\n",
    "knn_clf.fit(X_train_mod, y_train_mod)\n",
    "# 模型预测\n",
    "clean_digit = knn_clf.predict([X_test_mod[some_index]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 拿出图片\n",
    "plt.imshow(clean_digit.reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
